Ⅰ 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;
}
Ⅶ 二叉树遍历方法有几种
二叉树遍历方法最常用的大致有四种：
先序遍历，也叫先根遍历。就是先访问根结点，再访问左子树，最后访问右子树。
中序遍历，也叫中根遍历。就是先访问左子树，再访问根节点，最后访问右子树。
后序遍历，也叫后根遍历。就是先访问左子树，再访问右子树，最后访问根结点。
按层次遍历，就是对二叉树从上到下访问每一层，在每一层中都是按从左到右进行访问该层中的每一个节点。