树的遍历算法
⑴ 二叉树的递归遍历，其中先序遍历算法如xia void ProOrder(BiTree bt) {
从头开始，A不为空，A->lchild到达B，B不为空，B->lchild到达null，此时ProOrder(bt->lchild);执行完，执行ProOrder(bt->rchild);即ProOrder(B->lchild)到达D;到达D后又不为空，又开始执行ProOrder(bt->lchild)，即ProOrder(D>lchild)到达F。然后.......
去看一下递归的执行原理吧。如果有两个递归，第一个执行完之后才会执行第二个，当然，在执行第二个的时候，又会重新调用第一个，然后又等第一个执行完再执行第二个。
⑵ 什么叫遍历算法(最好有例子)
遍历算法：所谓遍历(Traversal)，是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题。遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算之基础。当然遍历的概念也适合于多元素集合的情况，如数组。
遍历算法概念延伸：
图遍历：图遍历又称图的遍历，属于数据结构中的内容。指的是从图中的任一顶点出发，对图中的所有顶点访问一次且只访问一次。图的遍历操作和树的遍历操作功能相似。图的遍历是图的一种基本操作，图的许多其它操作都是建立在遍历操作的基础之上。
举例：
遍历二叉树搜索路线：
从二叉树的递归定义可知，一棵非空的二叉树由根结点及左、右子树这三个基本部分组成。因此，在任一给定结点上，可以按某种次序执行三个操作：⑴访问结点本身（N），⑵遍历该结点的左子树（L），⑶遍历该结点的右子树（R）。以上三种操作有六种执行次序：NLR、LNR、LRN、NRL、RNL、RLN。前三种次序与后三种次序对称。
遍历二叉树的执行踪迹三种递归遍历算法的搜索路线相同（如下图虚线所示）。具体线路为：从根结点出发，逆时针沿着二叉树外缘移动，对每个结点均途径三次，最后回到根结点。
⑶ 二叉树的遍历
1．遍历方案 从二叉树的递归定义可知，一棵非空的二叉树由根结点及左、右子树这三个基本部分组成。因此，在任一给定结点上，可以按某种次序执行三个操作： （1）访问结点本身(N)， （2）遍历该结点的左子树(L)， （3）遍历该结点的右子树(R)。以上三种操作有六种执行次序： NLR、LNR、LRN、NRL、RNL、RLN。 注意： 前三种次序与后三种次序对称，故只讨论先左后右的前三种次序。 2．三种遍历的命名 根据访问结点操作发生位置命名： ① NLR：前序遍历(PreorderTraversal亦称(先序遍历)) ——访问结点的操作发生在遍历其左右子树之前。 ② LNR：中序遍历(InorderTraversal) ——访问结点的操作发生在遍历其左右子树之中(间)。 ③ LRN：后序遍历(PostorderTraversal) ——访问结点的操作发生在遍历其左右子树之后。 注意： 由于被访问的结点必是某子树的根，所以N(Node)、L(Left subtlee)和R(Right subtree)又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。 遍历算法 1．中序遍历的递归算法定义： 若二叉树非空，则依次执行如下操作： (1)遍历左子树； (2)访问根结点； (3)遍历右子树。 2．先序遍历的递归算法定义： 若二叉树非空，则依次执行如下操作： (1) 访问根结点； (2) 遍历左子树； (3) 遍历右子树。 3．后序遍历得递归算法定义： 若二叉树非空，则依次执行如下操作： (1)遍历左子树； (2)遍历右子树； (3)访问根结点。 ~
⑷ 二叉树遍历的算法实现
从二叉树的递归定义可知，一棵非空的二叉树由根结点及左、右子树这三个基本部分组成。因此，在任一给定结点上，可以按某种次序执行三个操作：
⑴访问结点本身（N），
⑵遍历该结点的左子树（L），
⑶遍历该结点的右子树（R）。
以上三种操作有六种执行次序：
NLR、LNR、LRN、NRL、RNL、RLN。
注意：
前三种次序与后三种次序对称，故只讨论先左后右的前三种次序。 根据访问结点操作发生位置命名：
① NLR：前序遍历(PreorderTraversal亦称（先序遍历））
——访问根结点的操作发生在遍历其左右子树之前。
② LNR：中序遍历(InorderTraversal)
——访问根结点的操作发生在遍历其左右子树之中（间）。
③ LRN：后序遍历(PostorderTraversal)
——访问根结点的操作发生在遍历其左右子树之后。
注意：
由于被访问的结点必是某子树的根，所以N(Node）、L(Left subtree）和R(Right subtree）又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。 1．先（根）序遍历的递归算法定义：
若二叉树非空，则依次执行如下操作：
⑴ 访问根结点；
⑵ 遍历左子树；
⑶ 遍历右子树。
2．中（根）序遍历的递归算法定义：
若二叉树非空，则依次执行如下操作：
⑴遍历左子树；
⑵访问根结点；
⑶遍历右子树。
3．后（根）序遍历得递归算法定义：
若二叉树非空，则依次执行如下操作：
⑴遍历左子树；
⑵遍历右子树；
⑶访问根结点。 用二叉链表做为存储结构，中序遍历算法可描述为：
void InOrder(BinTree T)
{ //算法里①~⑥是为了说明执行过程加入的标号
① if(T) { // 如果二叉树非空
② InOrder(T->lchild）；
③ printf(%c，T->data）； // 访问结点
④ InOrder(T->rchild);
⑤ }
⑥ } // InOrder 计算中序遍历拥有比较简单直观的投影法，如图
⑴在搜索路线中，若访问结点均是第一次经过结点时进行的，则是前序遍历；若访问结点均是在第二次（或第三次）经过结点时进行的，则是中序遍历（或后序遍历）。只要将搜索路线上所有在第一次、第二次和第三次经过的结点分别列表，即可分别得到该二叉树的前序序列、中序序列和后序序列。
⑵上述三种序列都是线性序列，有且仅有一个开始结点和一个终端结点，其余结点都有且仅有一个前驱结点和一个后继结点。为了区别于树形结构中前驱（即双亲）结点和后继（即孩子）结点的概念，对上述三种线性序列，要在某结点的前驱和后继之前冠以其遍历次序名称。
【例】上图所示的二叉树中结点C，其前序前驱结点是D，前序后继结点是E；中序前驱结点是E，中序后继结点是F；后序前驱结点是F，后序后继结点是A。但是就该树的逻辑结构而言，C的前驱结点是A，后继结点是E和F。
二叉链表基本思想
基于先序遍历的构造，即以二叉树的先序序列为输入构造。
注意：
先序序列中必须加入虚结点以示空指针的位置。
【例】
建立上图所示二叉树，其输入的先序序列是：ABD∮∮∮CE∮∮F∮∮。
构造算法
假设虚结点输入时以空格字符表示，相应的构造算法为：
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就指向了已构造好的二叉链表的根结点。
二叉树建立过程见
下面是关于二叉树的遍历、查找、删除、更新数据的代码（递归算法）： #include<iostream>#include<cstdio>#include<cmath>#include<iomanip>#include<cstdlib>#include<ctime>#include<algorithm>#include<cstring>#include<string>#include<vector>#include<list>#include<stack>#include<queue>#include<map>#include<set>usingnamespacestd;typedefintT;classbst{structNode{Tdata;Node*L;Node*R;Node(constT&d,Node*lp=NULL,Node*rp=NULL):data(d),L(lp),R(rp){}};Node*root;intnum;public:bst():root(NULL),num(0){}voidclear(Node*t){if(t==NULL)return;clear(t->L);clear(t->R);deletet;}~bst(){clear(root);}voidclear(){clear(root);num=0;root=NULL;}boolempty(){returnroot==NULL;}intsize(){returnnum;}TgetRoot(){if(empty())throwemptytree;returnroot->data;}voidtravel(Node*tree){if(tree==NULL)return;travel(tree->L);cout<<tree->data<<'';travel(tree->R);}voidtravel(){travel(root);cout<<endl;}intheight(Node*tree){if(tree==NULL)return0;intlh=height(tree->L);intrh=height(tree->R);return1+(lh>rh?lh:rh);}intheight(){returnheight(root);}voidinsert(Node*&tree,constT&d){if(tree==NULL)tree=newNode(d);elseif(ddata)insert(tree->L,d);elseinsert(tree->R,d);}voidinsert(constT&d){insert(root,d);num++;}Node*&find(Node*&tree,constT&d){if(tree==NULL)returntree;if(tree->data==d)returntree;if(ddata)returnfind(tree->L,d);elsereturnfind(tree->R,d);}boolfind(constT&d){returnfind(root,d)!=NULL;}boolerase(constT&d){Node*&pt=find(root,d);if(pt==NULL)returnfalse;combine(pt->L,pt->R);Node*p=pt;pt=pt->R;deletep;num--;returntrue;}voidcombine(Node*lc,Node*&rc){if(lc==NULL)return;if(rc==NULL)rc=lc;elsecombine(lc,rc->L);}boolupdate(constT&od,constT&nd){Node*p=find(root,od);if(p==NULL)returnfalse;erase(od);insert(nd);returntrue;}};intmain(){bstb;cout<<inputsomeintegers:;for(;;){intn;cin>>n;b.insert(n);if(cin.peek()=='
')break;}for(;;){cout<<inputdatapair:;intod,nd;cin>>od>>nd;if(od==-1&&nd==-1）break;b.update(od,nd);}}
⑸ 实现二叉树遍历的递归算法（求二叉树的节点总数，高度）
#include<stdlib.h>
#include<stdio.h>
#define MAXSIZE 100
typedef char ElemType;
typedef struct bonde
{
ElemType data;
struct bonde *lchild,*rchild;
}BTree;
typedef struct
{
BTree *data[MAXSIZE];
int top;
}Stack;
BTree *CreateBTree();
void porder(BTree *T);
int leafs(BTree *T);
int depth(BTree *T);
void main()//主函数
{
BTree *b;
int m,n;
printf("Create a tree....\n\n");
b=(BTree *)malloc(sizeof(int));
b=CreateBTree();
printf("\n");
porder(b);
m=leafs(b);
printf("\nthe tree's leafs:%d\n",m);
n=depth(b);
printf("\n\nthe tree's heigh:%d\n",n);
}
void StackInit(Stack *s)
{
s->top=-1;
}
int StackEmpty(Stack s)
{
if(s.top==-1)
return 1;
else
return 0;
}
int push(Stack *s,BTree *e)
{
if(s->top==MAXSIZE-1)
return 0;
else
{
(s->top)++;
s->data[s->top]=e;
return 1;
}
}
BTree *pop(Stack *s)
{
BTree *e;
if(s->top==-1)
return NULL;
else
{
e=s->data[(s->top)--];
return e;
}
}
BTree * CreateBTree()//建树过程
{
char ch;
BTree *b;
ch = getchar();
if(ch == '@')
{
b = NULL;
}
else
{
if(!(b = (BTree *)malloc(sizeof(BTree)))) exit(-1);
b->lchild = CreateBTree();
b->data=ch;
printf("%5c",p->data);
b->rchild = CreateBTree();
}
return b;
}
void porder(BTree *T)//先序遍历该树并输出
{
Stack s;
StackInit(&s);
while (t!=NULL||!StackEmpty(s))
{
if(t!=NULL)
{
printf("%c ",t->data);
push(&s,t);
t=t->lchild;
}
else
{
t=pop(&s);
t=t->rchild;
}
}
}
int leafs(BTree *T)、、求节点总数
{
int num1,num2;
if(T==NULL)
return 0;
else
if(T->lchild==NULL && T->rchild==NULL)
return 1;
else
{
num1=leafs(T->lchild);
num2=leafs(T->rchild);
return(num1+num2);
}
}
int depth(BTree *T)//求高度
{
int dep1,dep2;
if(T==NULL)
return 0;
else
{
dep1=depth(T->lchild);
dep2=depth(T->rchild);
if(dep1>dep2)
return(dep1+1);
else
return(dep2+1);
}
}
⑹ 伪代码写出树的先根遍历算法
function display_tree($root)
{
// 得到根节点的左右值
$result = mysql_query('SELECT lft, rgt FROM tree '.'WHERE name="'.$root.'";');
$row = mysql_fetch_array($result);
// 准备一个空的右值堆栈
$right = array();
// 获得根基点的所有子孙节点
$result = mysql_query('SELECT name, lft, rgt FROM tree '.
'WHERE lft BETWEEN '.$row['lft'].' AND '.
$row['rgt'].' ORDER BY lft ASC;');
// 显示每一行
while ($row = mysql_fetch_array($result))
{
// only check stack if there is one
if (count($right)>0)
{
// 检查我们是否应该将节点移出堆栈
while ($right[count($right)-1]<$row['rgt'])
{
array_pop($right);
}
}
// 缩进显示节点的名称
echo str_repeat(' ',count($right)).$row['name']."n";
// 将这个节点加入到堆栈中
$right[] = $row['rgt'];
}
}
⑺ 二叉树的遍历算法
递归算法的实现是依据栈来做的，建议你看一下关于这方面的内容。
preorder()函数功能为：若当前结点不为空，则打印当前值，并递归调用打印左右结点。
preorder()函数在每次递归调用前，先将下一条指令地址和参数压栈，即在执行preorder(root->Lchild)前，preorder(root->Rchild)地址及参数压栈。
以后每次递归调用均是如此。
递归函数返回时，也即root=NULL时，当前preoder(root->Rchild)指令出栈，继续向下执行，直到整个递归完成。
对于上述的树，执行过程如下：
1、打印1
2、调用打印2，打印3调用压栈
3、打印2
4、调用打印4，打印5调用压栈
5、打印4
6、调用打印4的左结点，打印4的右结点调用压栈
7、4无左结点，即当前结点=NULL，调用返回
8、栈中弹出打印4右结点调用
9、4无右结点，调用返回
10、栈中弹出打印5的调用
.....
一直这样执行下去，所以打印结果为：1-2-4-5-3-6
⑻ c++二叉树的几种遍历算法
遍历二叉树的所有结点且仅访问一次。按照根节点位置的不同分为前序遍历，中序遍历，后序遍历（除此之外还有层次遍历，但不常用，此处不做解释）。
1.前序遍历：根节点->左子树->右子树（根节点在前面）。
2.中序遍历：左子树->根节点->右子树（根节点在中间）。
3.后序遍历：左子树->右子树->根节点（根节点在后边）。
例如：求下面树的三种遍历：
前序遍历：abdefgc；
中序遍历：debgfac；
后序遍历：edgfbca。
⑼ 求二叉树遍历算法C语言实现的
Status
PreOrderTraverse
(
BiTree
T,
Status
(
*Visit
)
(
TElemType
e
)
)
{
//
采用二叉链表存储结构，Visit
是对数据元素操作的应用函数，先序遍历二叉树
T
的递归算法。
if
(
T
)
{
//
若
T
不为空
if
(
Visit
(
T->data
)
)
//
调用函数
Visit
if
(
PreOrderTraverse
(
T->lchild,
Visit
)
)
//
递归调用左子树
if
(
PreOrderTraverse
(
T->rchild,
Visit
)
)
return
OK;
//
递归调用右子树
return
ERROR;
}
else
return
OK;
}
//
PreOrderTraverse