導航:首頁 > 編程語言 > 二叉樹鋸齒層次遍歷python

二叉樹鋸齒層次遍歷python

發布時間:2023-03-26 23:04:54

Ⅰ 637. 二叉樹的層平均值(python

難度:★★☆☆☆
類型:樹

給定一個非空二叉樹, 返回一個由每層節點平均值組成的數組.

注意 :節點值的范圍在亂喊32位有符號整數范圍內。

輸入:

輸出: [3, 14.5, 11]
解釋:
第0層的平均值是 3, 第1層是 14.5, 第2層是 11. 因此返回 [3, 14.5, 11].

這道題實際上是二叉樹的層次遍歷,計算每一層的結點均值即可。

如有疑問或銀陪塵建議鋒禪,歡迎評論區留言~

Ⅱ 二叉樹--按層遍歷

今天練習的演算法是按層遍歷一個二叉樹。

我們還是用這張老的二叉樹來舉例子吧:

按層遍歷的意思是從樹的跟節點開始,一層層遍歷並輸出節點備睜的值。輸出的結果使用二維的數組存放,我們使用List<List<Integer>>來表示。上圖的結果為:
[
[F],
[B,G],
[A,D,I],
[C,E,H]
]

老規矩先看圖:

實現最主要的技巧就是使用隊列(Queue),我還是使用遞歸的思想來分析吧,每次進入遞歸前帶有四個參數orderList、queue、level、preSize。
先稍微分析下四個參數作用吧:

基本實現邏輯如下:
1.先從根節點開始,初始化orderList、queue、level、preSize,其中orderList為空,queue中存放root節仿兄歲點,level為0,preSize為1。
2.進入遞歸方法,首先循環從queue隊列中取出preSize數量的節點;然後挨個遍歷取出的節點,將節點的值添加到orderList對應的層(level)中;同時將節點的左右子節點均添加到queue隊列中,並且記錄存放到queue中的節點數量以備下次遞歸使用;最後根據記錄的下一層節點數量判斷是否需要繼續遞歸。

核心是要邊遍歷某一層的時候同時將該層節點的所有節點添加到queue中,並且記錄下一層總的節點塵衡數,這樣才能保證下一層遍歷時不會從隊列中取到非該層的節點。

演算法相關實現源碼地址: https://github.com/xiekq/rubs-algorithms

Ⅲ 遍歷二叉樹

遍歷方案:
1.遍歷方案
從二叉樹的遞歸定義可知,一棵非空的二叉樹由根結點及左、右子樹這三個基本部分組成。因此,在任一給定結點上,可以按某種次序執行三個操作:
(1)訪問結點本身(N),
(2)遍歷該結點的左子樹(L),
(3)遍歷該結點的右子樹(R)。
以上三種操作有六種執行次序:
NLR、LNR、LRN、NRL、RNL、RLN。
注意:
前三種次序與後三種次序對稱,故只討論先左後右的前三種次序。
2.三種遍歷的命名
根據訪問結點操作發生位置命名:
① NLR:前序遍歷(PreorderTraversal亦稱(先序遍歷))
——訪問結點的操作發生在遍歷其左右子樹之前。
② LNR:中序遍歷(InorderTraversal)
——訪問結點的操作發生在遍歷其左右子樹之中(間)。
③ LRN:後序遍歷(PostorderTraversal)
——訪問結點的操作發生在遍歷其左右子樹之後。
注意:
由於被訪問的結點必是某子樹的根,所以N(Node)、L(Left subtree)和R(Right subtree)又可解釋為根、根的左子樹和根的右子樹。NLR、LNR和LRN分別又稱為先根遍歷、中根遍歷和後根遍歷。
遍歷演算法
1.中序遍歷的遞歸演算法定義:
若二叉樹非空,則依次執行如下操作:
(1)遍歷左子樹;
(2)訪問根結點;
(3)遍歷右子樹。
2.先序遍歷的遞歸演算法定義:
若二叉樹非空,則依次執行如下操作:
(1) 訪問根結點;
(2) 遍歷左子樹;
(3) 遍歷右子樹。
3.後序遍歷得遞歸演算法定義:
若二叉樹非空,則依次執行如下操作:
(1)遍歷左子樹;
(2)遍歷右子樹;
(3)訪問根結點。
4.中序遍歷的演算法實現
用二叉鏈表做為存儲結構,中序遍歷演算法可描述為:
void InOrder(BinTree T)
{ //演算法里①~⑥是為了說明執行過程加入的標號
① if(T) { // 如果二叉樹非空
② InOrder(T->lchild);
③ printf("%c",T->data); // 訪問結點
④ InOrder(T->rchild);
⑤ }
⑥ } // InOrder
遍歷序列
1.遍歷二叉樹的執行蹤跡
三種遞歸遍歷演算法的搜索路線相同(如下圖虛線所示)。
具體線路為:
從根結點出發,逆時針沿著二叉樹外緣移動,對每個結點均途徑三次,最後回到根結點。
2.遍歷序列
A
/ \
B C
/ / \
D E F

(1) 中序序列(inorder traversal)
中序遍歷二叉樹時,對結點的訪問次序為中序序列
【例】中序遍歷上圖所示的二叉樹時,得到的中序序列為:
D B A E C F
(2) 先序序列(preorder traversal)
先序遍歷二叉樹時,對結點的訪問次序為先序序列
【例】先序遍歷上圖所示的二叉樹時,得到的先序序列為:
A B D C E F
(3) 後序序列(postorder traversal)
後序遍歷二叉樹時,對結點的訪問次序為後序序列
【例】後序遍歷上圖所示的二叉樹時,得到的後序序列為:
D B E F C A
(4)層次遍歷(level traversal)二叉樹的操作定義為:若二叉樹為空,則退出,否則,按照樹的結構,從根開始自上而下,自左而右訪問每一個結點,從而實現對每一個結點的遍歷
注意:
(1)在搜索路線中,若訪問結點均是第一次經過結點時進行的,則是前序遍歷;若訪問結點均是在第二次(或第三次)經過結點時進行的,則是中序遍歷(或後序遍歷)。只要將搜索路線上所有在第一次、第二次和第三次經過的結點分別列表,即可分別得到該二叉樹的前序序列、中序序列和後序序列。
(2)上述三種序列都是線性序列,有且僅有一個開始結點和一個終端結點,其餘結點都有且僅有一個前趨結點和一個後繼結點。為了區別於樹形結構中前趨(即雙親)結點和後繼(即孩子)結點的概念,對上述三種線性序列,要在某結點的前趨和後繼之前冠以其遍歷次序名稱。
【例】上圖所示的二叉樹中結點C,其前序前趨結點是D,前序後繼結點是E;中序前趨結點是E,中序後繼結點是F;後序前趨結點是F,後序後繼結點是A。但是就該樹的邏輯結構而言,C的前趨結點是A,後繼結點是E和F。
二叉鏈表的構造
1. 基本思想
基於先序遍歷的構造,即以二叉樹的先序序列為輸入構造。
注意:
先序序列中必須加入虛結點以示空指針的位置。
【例】
建立上圖所示二叉樹,其輸入的先序序列是:ABD∮∮∮CE∮∮F∮∮。
2. 構造演算法
假設虛結點輸入時以空格字元表示,相應的構造演算法為:
void CreateBinTree (BinTree *T)
{ //構造二叉鏈表。T是指向根指針的指針,故修改*T就修改了實參(根指針)本身
char ch;
if((ch=getchar())=='') *T=NULL; //讀人空格,將相應指針置空
else{ //讀人非空格
*T=(BinTNode *)malloc(sizeof(BinTNode)); //生成結點
(*T)->data=ch;
CreateBinTree(&(*T)->lchild); //構造左子樹
CreateBinTree(&(*T)->rchild); //構造右子樹
}
}
注意:
調用該演算法時,應將待建立的二叉鏈表的根指針的地址作為實參。
【例】
設root是一根指針(即它的類型是BinTree),則調用CreateBinTree(&root)後root就指向了已構造好的二叉鏈表的根結點。
二叉樹建立過程見http://student.zjzk.cn/course_ware/data_structure/web/flashhtml/erchashujianli.htm
下面是關於二叉樹的遍歷、查找、刪除、更新數據的代碼(遞歸演算法):
[code]
#include <iostream>
using namespace std;
typedef int T;
class bst{
struct Node{
T data;
Node* L;
Node* R;
Node(const T& d, Node* lp=NULL, Node* rp=NULL):data(d),L(lp),R(rp){}
};
Node* root;
int num;
public:
bst():root(NULL),num(0){}
void clear(Node* t){
if(t==NULL) return;
clear(t->L);
clear(t->R);
delete t;
}
~bst(){clear(root);}
void clear(){
clear(root);
num = 0;
root = NULL;
}
bool empty(){return root==NULL;}
int size(){return num;}
T getRoot(){
if(empty()) throw "empty tree";
return root->data;
}
void travel(Node* tree){
if(tree==NULL) return;
travel(tree->L);
cout << tree->data << ' ';
travel(tree->R);
}
void travel(){
travel(root);
cout << endl;
}
int height(Node* tree){
if(tree==NULL) return 0;
int lh = height(tree->L);
int rh = height(tree->R);
return 1+(lh>rh?lh:rh);
}
int height(){
return height(root);
}
void insert(Node*& tree, const T& d){
if(tree==NULL)
tree = new Node(d);
else if(ddata)
insert(tree->L, d);
else
insert(tree->R, d);
}
void insert(const T& d){
insert(root, d);
num++;
}
Node*& find(Node*& tree, const T& d){
if(tree==NULL) return tree;
if(tree->data==d) return tree;
if(ddata)
return find(tree->L, d);
else
return find(tree->R, d);
}
bool find(const T& d){
return find(root, d)!=NULL;
}
bool erase(const T& d){
Node*& pt = find(root, d);
if(pt==NULL) return false;
combine(pt->L, pt->R);
Node* p = pt;
pt = pt->R;
delete p;
num--;
return true;
}
void combine(Node* lc, Node*& rc){
if(lc==NULL) return;
if(rc==NULL) rc = lc;
else combine(lc, rc->L);
}
bool update(const T& od, const T& nd){
Node* p = find(root, od);
if(p==NULL) return false;
erase(od);
insert(nd);
return true;
}
};
int main()
{
bst b;
cout << "input some integers:";
for(;;){
int n;
cin >> n;
b.insert(n);
if(cin.peek()=='\n') break;
}
b.travel();
for(;;){
cout << "input data pair:";
int od, nd;
cin >> od >> nd;
if(od==-1&&nd==-1) break;
b.update(od, nd);
b.travel();
}
}
[/code]

Ⅳ 試完成二叉樹按層次(同一層自左至右)遍歷的演算法。

#include "iostream.h"
#include "stdlib.h"
#include "stdio.h"

typedef char ElemType;//定義二叉樹結點值的卜碧類型為字元型
const int MaxLength=10;//結點個數不超過10個

typedef struct BTNode{
ElemType data;
struct BTNode *lchild,*rchild;
}BTNode,* BiTree;

void CreateBiTree(BiTree &T){//按先序次序輸入,構造二叉鏈表表示的二叉樹T,空格表示空樹
// if(T) return;
char ch;
ch=getchar(); //不能用cin來輸入,在cin中不能識別空格。
if(ch==' ') T=NULL;
else{
if(!(T=(BTNode *)malloc(sizeof(BTNode)))) cout<<"malloc fail!";
T->data=ch;
CreateBiTree(T->lchild);
CreateBiTree(T->rchild);
}
}

void PreOrderTraverse(BiTree T){//先序遍歷
if(T){
cout<<T->data<<' ';
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
}
}
void InOrderTraverse(BiTree T){//中序遍歷
if(T){
InOrderTraverse(T->lchild);
cout<<T->data<<' ';
InOrderTraverse(T->rchild);
}
}
void PostOrderTraverse(BiTree T){//後序遍歷
if(T){
PostOrderTraverse(T->lchild);
PostOrderTraverse(T->rchild);
cout<<T->data<<' ';
}
}
void LevelOrderTraverse(BiTree T){//層序遍歷

BiTree Q[MaxLength];
int front=0,rear=0;
BiTree p;
if(T){ //根結點入隊
Q[rear]=T;
rear=(rear+1)%MaxLength;
}
while(front!=rear){
p=Q[front]; //隊頭元素出隊
front=(front+1)%MaxLength;
cout<<p->data<<' ';
if(p->lchild){ //左孩子不為空,入隊
Q[rear]=p->lchild;
rear=(rear+1)%MaxLength;
}
if(p->rchild){ //右孩子不為空,入隊
Q[rear]=p->rchild;
rear=(rear+1)%MaxLength;
}
}

}
//非皮仔遞歸的先序遍歷演算法
void NRPreOrder(BiTree bt)
{ BiTree stack[MaxLength],p;
int top;
if (bt!=NULL){
top=0;p=bt;
while(p!=NULL||top>0)
{ while(p!=NULL)
{
cout<<p->data;
stack[top]=p;
top++;
p=p->lchild;
}
if (top>0)
{ top--; p=stack[top]; p=p->rchild; }
}
}
}
//非遞歸的中序遍歷演算法
void NRInOrder(BiTree bt)
{ BiTree stack[MaxLength],p;
int top;
if (bt!=NULL){
top=0;p=bt;
while(p!=NULL||top>0)
{ while(p!=NULL)
{

stack[top]=p;
top++;
p=p->lchild;
}
if (top>0)
{ top--; p=stack[top];cout<<p->data; p=p->rchild; }
}
}
}
//非遞歸型握舉的後序遍歷演算法
/*bt是要遍歷樹的根指針,後序遍歷要求在遍歷完左右子樹後,再訪問根。
需要判斷根結點的左右子樹是否均遍歷過。
可採用標記法,結點入棧時,配一個標志tag一同入棧
(1:遍歷左子樹前的現場保護,2:遍歷右子樹前的現場保護)。
首先將bt和tag(為1)入棧,遍歷左子樹;
返回後,修改棧頂tag為2,遍歷右子樹;最後訪問根結點。*/

typedef struct
{
BiTree ptr;
int tag;
}stacknode;

void NRPostOrder(BiTree bt)
{
stacknode s[MaxLength],x;
BiTree p=bt;
int top;
if(bt!=NULL){
top=0;p=bt;
do
{
while (p!=NULL) //遍歷左子樹
{
s[top].ptr = p;
s[top].tag = 1; //標記為左子樹
top++;
p=p->lchild;
}

while (top>0 && s[top-1].tag==2)
{
x = s[--top];
p = x.ptr;
cout<<p->data; //tag為R,表示右子樹訪問完畢,故訪問根結點
}

if (top>0)
{
s[top-1].tag =2; //遍歷右子樹
p=s[top-1].ptr->rchild;
}
}while (top>0);}
}//PostOrderUnrec

int BTDepth(BiTree T){//求二叉樹的深度
if(!T) return 0;
else{
int h1=BTDepth(T->lchild);
int h2=BTDepth(T->rchild);
if(h1>h2) return h1+1;
else return h2+1;
}
}

int Leaf(BiTree T){//求二叉樹的葉子數
if(!T) return 0;
else if(!T->lchild&&!T->rchild) return 1;
else return(Leaf(T->lchild)+Leaf(T->rchild));
}

int NodeCount(BiTree T){//求二叉樹的結點總數
if(!T) return 0;
else return NodeCount(T->lchild)+NodeCount(T->rchild)+1;
}

void main(){
BiTree T;
T=NULL;
int select;
//cout<<"請按先序次序輸入各結點的值,以空格表示空樹(輸入時可連續輸入):"<<endl;
// CreateBiTree(T);
while(1){
cout<<"\n\n請選擇要執行的操作:\n";
cout<<"1.創建二叉樹\n";
cout<<"2.二叉樹的遞歸遍歷演算法(前、中、後)\n";
cout<<"3.二叉樹的層次遍歷演算法\n";
cout<<"4.求二叉樹的深度\n";
cout<<"5.求二叉樹的葉子結點\n";
cout<<"6.求二叉樹的結點總數\n";
cout<<"7.二叉樹的非遞歸遍歷演算法(前、中、後)\n"; //此項可選做
cout<<"0.退出\n";
cin>>select;
switch(select){
case 0:return;
case 1:
cout<<"請按先序次序輸入各結點的值,以空格表示空樹(輸入時可連續輸入):"<<endl;
CreateBiTree(T);
break;
case 2:
if(!T) cout<<"未建立樹,請先建樹!";
else{
cout<<"\n先序遍歷:\n";
PreOrderTraverse(T);
cout<<"\n中序遍歷:\n";
InOrderTraverse(T);
cout<<"\n後序遍歷:\n";
PostOrderTraverse(T);
}
break;
case 3:
cout<<"\n層序遍歷:\n";
LevelOrderTraverse(T);
break;
case 4:
cout<<"二叉樹的深度為:\n";
cout<<BTDepth(T);
break;
case 5:
cout<<"\n葉子節點數:\n";
cout<<Leaf(T);
break;
case 6:
cout<<"總節點數:\n";
cout<<NodeCount(T);
break;
case 7:
if(!T) cout<<"未建立樹,請先建樹!";
else{
cout<<"\n先序遍歷:\n";
NRPreOrder(T);
cout<<"\n中序遍歷:\n";
NRInOrder(T);
cout<<"\n後序遍歷:\n";
NRPostOrder(T);
}
break;
default:
cout<<"請確認選擇項:\n";
}//end switch
}//end while

}
參考資料:找來的,你看看吧!

Ⅳ Python演算法系列—深度優先遍歷演算法

一、什麼是深度優先遍歷
深度優先遍歷演算法是經典的圖論演算法。從某個節點v出發開始進行搜索。不斷搜索直到該節點所有的邊都被遍歷完,當節點v所有的邊都被遍歷完以後,深度優先遍歷演算法則需要回溯到v以前驅節點來繼續搜索這個節點。
注意:深度優先遍歷問題一定要按照規則嘗試所有的可能才行。

二、二叉樹

2.二叉樹類型
二叉樹類型:空二叉樹、滿二叉樹、完全二叉樹、完美二叉樹、平衡二叉樹。

空二叉樹:有零個節點
完美二叉樹:每一層節點都是滿的二叉樹(如1中舉例的圖)
滿二叉樹:每一個節點都有零個或者兩個子節點
完全二叉樹:出最後一層外,每一層節點都是滿的,並且最後一層節點全毀行歷部從左排列
平衡二叉樹:每個節點的兩個子樹的深度相差不超過1.

註:國內對完美二叉樹和滿二叉樹定義相同
3.二叉樹相關術語
術語 解釋
度 節點的度為節點的子樹個數
葉子節點 度為零的節點
分支節點 度不為零的節點
孩子節點 節點下的兩個子節點
雙親節點 節點上一層的源節點
兄弟節點 擁有同一雙親節點的節點
根 二叉樹的源頭節點
深度 二叉樹中節點的層的數量

DLR(先序):
LDR(中序):
LRD(後序):
注意:L代表左子樹R代表右子樹;D代表根

6.深度優先遍歷和廣度優先遍歷
深度優先遍歷:前序、中序和後序都是深度優先遍歷
從根節點出發直奔最遠節點,
廣度優先遍歷:首先訪問舉例根節點最近的節纖搜點,按層次遞進,以廣度優先遍歷上圖的順序為:1-2-3-4-5-6-7
三、面試題+勵志
企鵝運維面試題:帶局
1.二叉樹遍歷順序:看上文
2.用你熟悉的語言說說怎麼創建二叉樹? python看上文

Ⅵ 我要二叉樹代碼遞歸遍歷,非遞歸遍歷,層次遍歷。

#include<stdio.h>
#include<stdlib.h>
typedef char datatype;
typedef struct bitnode
{
datatype data;
struct bitnode *lchild,*rchild;
}tree;
tree *init()
{
tree *bt;
bt=NULL;
bt=(tree*)malloc(sizeof(tree));
bt->lchild=NULL;
bt->rchild=NULL;
return bt;
}
tree *create(tree *bt)
{
char ch;
scanf("%c",&ch);
if(ch=='0')
{
bt=NULL;
return bt;
}
else
{
bt=(tree *)malloc(sizeof(tree));
bt->data=ch;
bt->lchild=create(bt->lchild);
bt->rchild=create(bt->rchild);
}
return bt;
}
tree *Linsert(datatype x,tree *parent)
{
tree *p;
if(parent==NULL)
{
printf("insert error\n");
return NULL;
}
if((p=(tree*)malloc(sizeof(tree)))==NULL)
return NULL;
p->data=x;
p->lchild=NULL;
p->rchild=NULL;
if(parent->lchild==NULL)
parent->lchild=p;
else
{
p->lchild=parent->lchild;
parent->lchild=p;
}
return parent;
}
tree *Rinsert(datatype x,tree *parent)
{
tree *p;
if(parent==NULL)
{
printf("insert error\n");
return NULL;
}
if((p=(tree*)malloc(sizeof(tree)))==NULL)
return NULL;
p->data=x;
p->lchild=NULL;
p->rchild=NULL;
if(parent->rchild==NULL)
parent->rchild=p;
else
{
p->rchild=parent->rchild;
parent->知者逗rchild=p;
}
return parent;
}
tree *Ldel(tree *parent)
{
tree *p;
if(parent==NULL||parent->lchild==NULL)
{
printf("delete error\n");
return NULL;
}
p=parent->lchild;
parent->lchild=NULL;
free(p);
return parent;
}
tree *Rdel(tree *parent)
{
tree *p;
if(parent==NULL||parent->rchild==NULL)
{
printf("delete error\n");
return NULL;
}
p=parent->搭賣rchild;
parent->rchild=NULL;
free(p);
return parent;
}
void visit(tree *bt)
{
printf("%c ",bt->data);
}
void preorder(tree *bt)
{
if(bt==NULL)
return ;
visit(bt);
preorder(bt->lchild);
preorder(bt->rchild);
}
void inorder(tree *bt)
{
if(bt==NULL)
return ;
inorder(bt->嫌仿lchild);
visit(bt);
inorder(bt->rchild);
}
void postorder(tree *bt)
{
if(bt==NULL)
return ;
postorder(bt->lchild);
postorder(bt->rchild);
visit(bt);
}

tree *search(tree *bt,datatype x)
{
tree *p;
p=NULL;
if(bt)
{
if(bt->data==x)
return bt;
if(bt->lchild)
p=search(bt->lchild,x);
if(p!=NULL)
return p;
if(bt->rchild)
p=search(bt->rchild,x);
if(p!=NULL)
return p;
}
return p;
}

void nrpreorder(tree *bt)
{
tree *stack[1000],*p;
int top=-1;
if(bt==NULL)
return ;
p=bt;
while(!(p==NULL&&top==-1))
{
while(p!=NULL)
{
visit(p);
top++;
stack[top]=p;
p=p->lchild;
}
if(top<0)
return ;
else
{
p=stack[top];
top--;
p=p->rchild;
}
}

}

void nrinorder(tree *bt)
{
tree *stack[1000],*p;
int top=-1;
if(bt==NULL)
return ;
p=bt;
while(!(p==NULL&&top==-1))
{
while(p!=NULL)
{
top++;
stack[top]=p;
p=p->lchild;
}
if(top<0)
return ;
else
{
p=stack[top];
top--;
visit(p);
p=p->rchild;
}
}

}

void nrpostorder(tree *bt)
{
int top;
tree *d[1000],*dd;
tree *stack[1000],*p;
if(bt==NULL)
return ;
top=-1;
p=bt;
while(!(p==NULL&&top==-1))
{
while(p!=NULL)
{
top++;
stack[top]=p;
p=p->lchild;
}
dd=stack[top];
if(top>-1)
if(dd)
{
p=stack[top]->rchild;
d[top]=stack[top];
stack[top]=NULL;
dd=NULL;
}
else
{
p=d[top];
top--;
visit(p);
p=NULL;
}
}
}
void levelorder(tree *bt)
{
tree *queue[1000];
int front,rear;
if(bt==NULL)
return ;
front=-1;
rear=0;
queue[rear]=bt;
while(front!=rear)
{
front++;
visit(queue[front]);
if(queue[front]->lchild!=NULL)
{
rear++;
queue[rear]=queue[front]->lchild;
}
if(queue[front]->rchild!=NULL)
{
rear++;
queue[rear]=queue[front]->rchild;
}
}
}

int countleaf(tree *bt)
{
if(bt==NULL)
return 0;
if(bt->lchild==NULL&&bt->rchild==NULL)
return 1;
return(countleaf(bt->lchild)+countleaf(bt->rchild));
}
int main()
{
tree *bt,*p;
int n=1,m,t;
char x;
printf("-----------------------程序說明---------------------------\n");
printf("1.本程序涉及二叉樹的所有操作。\n");
printf("2.創建操作為先序輸入,輸入0代表空。\n");
printf("3.刪除操作和插入操作之前必須使用查找操作找到其雙親。\n");
printf("4.輸入回車鍵開始本程序。\n");
printf("----------------------------------------------------------\n");
getchar();
while(n!=0)
{
printf("choose:\n1、Create a bitree 2、Search\n3、Preorder 4、Inorder 5、Postorder\n6、Levelorder 7、The number of leaves \n0、End\n");
printf("Do: ");
scanf("%d",&n);
getchar();
switch(n)
{
case 1:
bt=init();
printf("Create a bitree :");
bt=create(bt);
break;
case 2:
printf("Input a char :");
scanf("%c",&x);
getchar();
p=search(bt,x);
if(p!=NULL)
{
printf("1、do nothing \n2、Insret L-tree 3、Insert R-tree \n4、Delete L-tree 5、Delete R-tree \n");
printf("Do: ");
scanf("%d",&m);
getchar();
switch(m)
{
case 1: break;
case 2:
printf("Input a char :");
scanf("%c",&x);
Linsert(x,p);
break;
case 3:
printf("Input a char :");
scanf("%c",&x);
Rinsert(x,p);
break;
case 4:
if(Ldel(p)!=NULL)
printf("Complish delete !\n");
break;
case 5:
if(Rdel(p)!=NULL)
printf("Complish delete !\n");
break;
default : printf("Input error\n");
}
}
else printf("The char dose not exist\n");
break;
case 3:
printf("1、Recursive 2、Nonrecursive\n");
printf("Do: ");
scanf("%d",&t);
if(t==1)
preorder(bt);
else
nrpreorder(bt);
printf("\n");
break;
case 4:
printf("1、Recursive 2、Nonrecursive\n");
printf("Do: ");
scanf("%d",&t);
if(t==1)
inorder(bt);
else
nrinorder(bt);
printf("\n");
break;
case 5:
printf("1、Recursive 2、Nonrecursive\n");
printf("Do: ");
scanf("%d",&t);
if(t==1)
postorder(bt);
else
nrpostorder(bt);
printf("\n");
break;
case 6:
levelorder(bt);
break;
case 7:
printf("%d\n",countleaf(bt));
break;
case 0:break;
default : printf("Input error\n");
}
printf("\n");
}
return 0;
}

Ⅶ 二叉樹遍歷方法有幾種

二叉樹遍歷方法最常用的大致有四種:
先序遍歷,也叫先根遍歷。就是先訪問根結點,再訪問左子樹,最後訪問右子樹。
中序遍歷,也叫中根遍歷。就是先訪問左子樹,再訪問根節點,最後訪問右子樹。
後序遍歷,也叫後根遍歷。就是先訪問左子樹,再訪問右子樹,最後訪問根結點。
按層次遍歷,就是對二叉樹從上到下訪問每一層,在每一層中都是按從左到右進行訪問該層中的每一個節點。

閱讀全文

與二叉樹鋸齒層次遍歷python相關的資料

熱點內容
畫單片機最小系統 瀏覽:830
外包程序員35歲以後干什麼 瀏覽:107
java怎麼重新編譯class文件 瀏覽:571
pythonweb開發與介面測試用例 瀏覽:396
python必背筆記 瀏覽:319
陳鋒羽婷的小說 瀏覽:464
安卓怎麼下載正版刺激戰場 瀏覽:235
xrv本田壓縮比 瀏覽:63
空調耗電量手機app怎麼看 瀏覽:723
伺服器怎麼登錄u8 瀏覽:909
明星pdf 瀏覽:270
判斷手機訪問php 瀏覽:119
appstory怎麼設密碼 瀏覽:798
程序員月薪3萬 瀏覽:261
flash反編譯覆蓋碼怎麼找 瀏覽:196
女大男小忘年戀題材電影 瀏覽:83
築業軟體如何查找加密鎖 瀏覽:114
電信盒子系統升級伺服器地址 瀏覽:584
海康威視伺服器如何設置dns 瀏覽:911
空調壓縮機檢測方法 瀏覽:529