树和二叉树的基本知识教学教材.doc

树和二叉树的基本知识

精品文档
树和二叉树的基本知识

树是一种非线性的数据结构，用它能很好地描述有分支和层次特性的数据集合。树型结构在现实世界中广泛存在，如把一个家族看作为一棵树，树中的结点为家族成员的姓名及相关信息，树中的关系为父子关系，即父亲是儿子的前驱，儿子是父亲的后继；把一个国家或一个地区的各级行政区划分看作为一棵树，树中的结点为行政区的名称及相关信息，树中的关系为上下级关系，如一个城市包含有若干个区，每个区又包含有若干个街道，每个街道又包含有若干个居委会；把一本书的结构看作是一棵树，树中的结点为书、章、节的名称及相关信息，树中的关系为包含关系。树在计算机领域中也有广泛应用，如在编译系统中，用树表示源程序的语法结构；在数据库系统中，树型结构是数据库层次模型的基础，也是各种索引和目录的主要组织形式。在许多算法中，常用树型结构描述问题的求解过程、所有解的状态和求解的对策等。
在树型结构中，二叉树是最常用的结构，它的分支个数确定，又可以为空，具有良好的递归特性，特别适宜于程序设计，因此我们常常将一般树型结构转换成二叉树进行处理。

第一节 树
一、树的定义
一棵树（tree）是由n（n>0）个元素组成的有限集合，其中：
1．每个元素称为结点(node)；
2．有一个特定的结点，称为根结点或树根（root）；
3．除根结点外，其余结点被分成m（m>=0）个互不相交的有限集合T0,T1,T2,……Tm-1，而每一个子集Ti又都是一棵树（称为原树的子树subtree）。

图1
图1就是一棵典型的树结构。从树的定义可以看出：
1．树是递归定义的，这就决定了树的操作和应用大都是采用递归思想来解决；
2．一棵树中至少有1个结点，这个结点就是根结点，如上图中的结点1；
3．只有根结点没有前趋结点，其余每个结点都有唯一的一个前趋结点；
4．所有结点都可以有0或多个后继结点；
二、树的基本概念
下面以图1为例给出树结构中的一些基本概念：
1．一个结点的子树个数，称为这个结点的度（degree），如结点1的度为3，结点3的度为0。度为0的结点称为叶结点（又称树叶leaf，如结点3、5、6、8、9）。度不为0的结点称为分支结点（如结点1、2、4、7）。根结点以外的分支结点又称为内部结点（如结点2、4、7）。树中各结点的度的最大值称为这棵树的度（又称宽度），图1所示这棵树的（宽）度为3。
2．在用上述图形表示的树结构中，对两个用线段（称为树枝）连接的相关联的结点，称上端的结点为下端结点的父结点，称下端的结点为上端结点的子结点，称同一个父结点的多个子结点为兄弟结点。如结点1是结点2、3、4的父结点，结点 2、3、4都是结点1的子结点，它们又是兄弟结点，同时结点2又是结点5、6的父结点。称从根结点到某个子结点所经过的所有结点为这个子结点的祖先。如结点1、4、7是结点8的祖先。称以某个结点为根的子树中的任一结点都是该结点的子孙。如结点7、8、9都是结点4的子孙。
3．定义一棵树的根结点的层次（level）为1，其它结点的层次等于它的父结点的层次数加1。如结点2、3、4的层次为2，结点5、6、7的层次为3，结点8、9的层次为4。一棵树中所有结点的层次的最大值称为树的深度（depth），图1所示这棵树的深度为4。
4．若树中各结点的子树是按照一定的次序从左向右安排的，它们之间的次序不能互换，这样的树称之为有序树，否则称之为无序树。所以，树虽然是非线性结构，但也是有序结构。例如，对于下面图2中的两棵树，若看作为无序树，则是相同的；若看作为有序树，则是不同的，因为根结点A的两棵子树的次序不同。又如对于一棵反映了父子关系的家族树，兄弟结点之间是按照排行大小而有序排列的，所以它是一棵有序树。因为任何无序树都可以当作具有任一次序的有序树来处理，所以下面如果不特别指明，均认为树是有序的。

图2
5.对于一棵子树中的任意两个不同的结点，如果从一个结点出发，按层次自上而下沿着一个个树枝能到达另一结点，称它们之间存在着一条路径。可用路径所经过的结点序列表示路径，路径的长度等于路径上的结点个数减1。如图1中，结点1和结点8之间存在着一条路径，并可用（1、4、7、8）表示这条路径，该条路径的长度为3。从根结点出发，到树中的其余结点一定存在着一条路径。注意，不同子树上的结点之间不存在路径。但是，如果把树看成是一个图的话(可以把树理解为是图的一个子类)，那么我们就可以继承图的路径的定义，认为不同子树上的两个结点应该是有路径的（图论意义上的路径）。
6．森林（forest）是m(m>=0)棵互不相交的树的集合。
三、树的表示方法和存储结构
树的表示方法有多种，如图1采用的就是一种形象的树形表示法；另外还有一种常用的表示方法“括号表示法”，它的表示方法归纳如下：先将整棵树的根结点放入一对圆括号中，然后把它的子树由左至右放入括号中，同层子树用圆括号括在一起（同层子树之间用逗号隔开），而对子树也采用同样的方法处理，直到所有的子树都只有一个根结点为止。用括号表示法表示图1的步骤如下：
=（T）
=（1（T1，T2 ，T3 ）） {A是根结点，有3棵子树，用逗号隔开}
=（1（2（T11，T12），3，4（T31））） {分别对3棵子树做同样的操作}
=（1（2（5，6），3，4（7（T311，T312））））
=（1（2（5，6），3，4（7（8，9））））
实际上，以上方法是按照树的层次逐步展开，直到所有结点都已列出。

树的存储结构也有多种形式，其中使用较多的采是链式存储结构，下面给出几种常见的存储树的数据结构。
1．父亲表示法：定义一个数组，每个数组元素为一个记录，除了存放一个结点的数据信息外，还存放该结点的父结点编号。数据结构定义如下：
Const m=10； {树的结点数}
Type node=Record
data:Integer； {数据域}
parent:Integer； {指针域}
End；
Var tree:Array[1..m] Of node；
这种方法充分利用了树中除根结点外每个结点都有唯一的父结点这个性质，很容易找到树根（可以规定根结点的父结点为0），但找孩子时却需要遍历整个线性表。

2．孩子表示法：利用单链表，每个结点包括一个数据域和若干个指针域，每个指针都指向一个孩子结点。由于一般树的各个结点的孩子数不确定，所以指针数应该等于整棵树的度。当树的度越大时，空指针域所占比例也越大，给存储空间造成很大浪费。假设树的度为10，树的结点仅存放字符，则这棵树的数据结构定义如下：
Const m=10； {树的度}
Type tree=^node；
node=Record
data:Char； {数据域}
child:Array[1..m] Of tree {指针域，指向若干孩子结点}
End；
Var t:tree；
注：空间上的浪费其实可以用“虚开实用”的方法完美地解决，在FreePascal等环境下可以用Getmem、Freemem等过程达到这个目的，这样建立一棵普通树的时间复杂度也是很不错的。有兴趣的同学可以参考有关书籍与程序。
由于每个结点都只存放各自孩子结点的编号，所以这种方法只能从根（父）结点遍历到子结点，不能从某个子结点返回到它的父结点。

3．父亲孩子表示法：利用双链表结构，每个结点包括一个数据域和二个指针域，一个指向该结点的若干孩子结点，一个指向其父结点。克服了上述第1种存储方法的缺点，假设树的度为10，树的结点仅存放字符，则这棵树的数据结构定义如下：
Const m=10；
Type tree=^node；
node=Record
data:Char；
child:Array[1..m] Of tree；
father:tree
End；
Var t:tree；

4．孩子兄弟表示法：有些程序中需要对兄弟结点进行处理，这种情况下，可以使用另外一种双链表结构，每个结点包括一个数据域和二个指针域，一个指针指向该结点的第一个孩子结点，一个指针指向该结点的下一个兄弟结点。克服了上述第2种存储方法的缺点，假设树的度为10，树的结点仅存放字符，则这棵树的数据结构定义如下：
Type tree=^node；
node=Record
data:Char；
firstchild,next: tree；
End；
Var t:tree；

四、树的遍历
在应用树结构解决问题时，往往需要按照某种次序获得树中全部结点的信息，这种操作叫做“树的遍历”。遍历一般按照从左向右的顺序，常用的遍历方法有：
1．先序（根）遍历：先访问根结点，再从左到右按照先序思想遍历各棵子树。
图1先序遍历的结果为：{1，2，5，6，3，4，7，8，9}；
2．后序（根）遍历：先从左到右遍历各棵子树，再访问根结点。
图1后序遍历的结果为：{5，6，2，3，8，9，7，4，1}；
3．层次遍历：按层次从小到大逐个访问，同一层次按照从左到右的次序。
图1层次遍历的结果为：{1，2，3，4，5，6，7，8，9}；
4．叶结点遍历：有时我们把所有的数据信息都存放在叶结点中，而其余结点都是用来表示数据之间的某种分支或层次关系，这种情况就用这种方法。
图1按照这个思想访问的结果为：{5，6，3，8，9}；

很明显，先序遍历和后序遍历两种方法的定义是递归的，所以在程序实现时往往也是采用递归的思想，既通常所说的“深度优先搜索”。按照先序遍历思想编写的递归过程如下：
Procedure tra1(t,m) {访问以t为根结点的含有m棵子树的过程}
Begin
If t <>Nil Then Begin
Write(t^.data,’ ’)； {访问根结点}
For I:=1 To m Do {前序遍历各子树}
tra1(t^.child[I],m)；
End；
End；
也可以用堆栈的方法编写这个程序，留给读者作为练习。

层次遍历应用也较多，实际上就是我们所说的“广度优先搜索”。思想如下：若某个结点被访问，则该结点的子结点应被记录下来，等待被访问。顺序访问各层次上结点，直至不再有未访问过的结点。为此，引入一个队列来存储等待访问的子结点，设一个队首和队尾指针分别表示出队、进队的下标。程序框架如下：
Const n=100；
Var head,tail,i:integer；
q:array[1..n] of tree；
p:tree；
Begin
tail:=1；head:=1； {初始化}
q[tail]:=t；tail:=tail+1； {t进队}
While ( head<tail) do Begin {队列非空}
p:=q[head]；head:=head+1； {取出队首结点}
Write(p^.data,‘ ‘)； {访问某结点}
For i:=1 To m Do {该结点的所有子结点按顺序进队}
If p^.child[i]<>Nil Then Begin
q[tail]:=p^.child[I]；tail:=tail+1；
End；
End；
End；

例1：单词查找树
[问题描述] 在进行文法分析的时候，通常需要检测一个单词是否在我们的单词列表里。为了提高查找和定位的速度，通常都画出与单词列表所对应的单词查找树，其特点如下：
1．根结点不包含字母，除根结点外每一个结点都仅包含一个大写英文字母；
2．从根结点到某一结点，路径上经过的字母依次连起来所构成的字母序列，称为该结点对应的单词。单词列表中的每个单词，都是该单词查找树某个结点所对应的单词；
3．在满足上述条件下，该单词查找树的结点数最少。
4．例如图3左边的单词列表就对应于右边的单词查找树。注意，对一个确定的单词列表，请统计对应的单词查找树的结点数（包含根结点）。
[问题输入]
输入文件名为word.in，该文件为一个单词列表，每一行仅包含一个单词和一个换行/回车符。每个单词仅由大写的英文字母组成，长度不超过63个字母 。文件总长度不超过32K，至少有一行数据。
[问题输出]
输出文件名为word.out，该文件中仅包含一个整数，该整数为单词列表对应的单词查找树的结点数。

[样例输入]
A
AN
ASP
AS
ASC
ASCII
BAS
BASIC
[样例输出]
13 图3

[算法分析]
首先要对建树的过程有一个了解。对于当前被处理的单词和当前树：在根结点的子结点中找单词的第一位字母，若存在则进而在该结点的子结点中寻找第二位……如此下去直到单词结束，即不需要在该树中添加结点；或单词的第n位不能被找到，即将单词的第n位及其后的字母依次加入单词查找树中去。但，本问题只是问你结点总数，而非建树方案，且有32K文件，所以应该考虑能不能通过不建树就直接算出结点数？为了说明问题的本质，我们给出一个定义：一个单词相对于另一个单词的差：设单词1的长度为L，且与单词2从第N位开始不一致，则说单词1相对于单词2的差为L-N+1，这是描述单词相似程度的量。可见，将一个单词加入单词树的时候，须加入的结点数等于该单词树中已有单词的差的最小值。
单词的字典顺序排列后的序列则具有类似的特性，即在一个字典顺序序列中，第m个单词相对于第m-1个单词的差必定是它对于前m-1个单词的差中最小的。于是，得出建树的等效算法：
① 读入文件；
② 对单词列表进行字典顺序排序；
③ 依次计算每个单词对前一单词的差，并把差累加起来。注意：第一个单词相对于“空”的差为该单词的长度；
④ 累加和再加上1（根结点），输出结果。

就给定的样例，按照这个算法求结点数的过程如下表：
表1
原单词列表
排序后的列表
差值
总计
输出
A
A
1
12
13
AN
AN
1
ASP
AS
1
AS
ASC
1
ASC
ASCII
2
ASCII
ASP
1
BAS
BAS
3
BASIC
BASIC
2

[数据结构] 先确定32K（32*1024=32768字节）的文件最多有多少单词和字母。当然应该尽可能地存放较短的单词。因为单词不重复，所以长度为1的单词（单个字母）最多26个；长度为2的单词最多为26*26=676个；因为每个单词后都要一个换行符（换行符在计算机中占2个字节），所以总共已经占用的空间为：（1+2）*26+（2+2）*676=2782字节；剩余字节（32768-2782=29986字节）分配给长度为3的单词（长度为3的单词最多有 26*26*26=17576个）有29986/（3+2）≈5997。所以单词数量最多为26+676+5997=6699。
定义一个数组：a：array[1..32767] of char；把所有单词连续存放起来，文件中每个单词后的换行符转换成数组中的一个“空格”字符。这样既省略了一个存放单词长度的数组，又方便且节省了一点空间。另外为了排序，再设一个数组index:array[1.. 6700] of integer；存放每个单词在a中的起始位置。这样，排序时用a比较，但只要交换index的值就可以了。
[参考程序]
Program p1(Input, Output)；
Var
a:Array[1..32767] Of Char；
index:Array[1..6700] Of Integer；
n,k,i,j,tot,t:Integer；
s,pre,now:String；
Function cmp(i, j:Longint):Boolean；{比较从a[i]开始的字符串和从a[j]开始的字符串
Begin 大小，小于则返回False，否则返回True}
While ((a[i]=a[j]) And (Ord(a[i])<>32) And (Ord(a[j])<>32)) Do
Begin Inc(i)；Inc(j)；End；
If (a[i]<a[j]) Then cmp := False Else cmp := True；
End；
Begin {main}
Assign(Input,'word.in')； Reset(Input)；
Assign(Output,'word.out')；Rewrite(Output)；
Fillchar(a, sizeof(a), 0)；
n := 0；{单词个数}
k := 0；{下标}
While (Not Eof) Do {读入文件中的单词并且存储到数组中}
Begin
Readln(s)；
n := n+1；
index[n] := k+1；{第n个单词的首字母起点下标}
For i:=1 To Length(s) Do {存入一个单词}
a[k+i] := s[i]；
k := k+i+1； {为下个单词的下标设定好初值,i即为当前单词的长度}
End；
For i:=1 To n Do {n个单词的字典排序}
For j:=i+1 To n Do
If cmp(index[i], index[j]) Then
Begin t := index[i]；index[i] := index[j]；index[j] := t；End；
tot := 0； {计数器}
pre := ''； {前一个单词}
For i:=1 To n Do {统计}
Begin
now := ''；
j := index[i]； {第i个单词的首字母在a数组中的下标为j}
While (Ord(a[j])<>0) Do {换行符换成了空格}
Begin now := now + a[j]；j := j+1；End； {当前处理的单词存入now中}
j := 1；
While ((pre[j]=now[j]) And (j<=length(pre))) Do Inc(j)；{求两个单词的差}
tot := tot+(Length(now)-j+1)； {累加}
pre := now；{把当前单词作为下次比较的前一个单词}
End；
Writeln(tot+1)；
Close(Input)；
Close(Output)；
End.

第二节 二叉树
一、二叉树的概念
二叉树（binary tree,简写成BT）是一种特殊的树型结构，它的特点是每个结点至多只有二棵子树，即二叉树中不存在度大于2的结点，而且二叉树的子树有左子树、右子树之分，孩子有左孩子、右孩子之分，其次序不能颠倒，所以二叉树是一棵有序树。它有如下5种基本形态：

图4
第一节讲述的树的一些术语、概念也基本适用于二叉树，但二叉树与树也有很多不同，如：二叉树的每个结点至多只能有两个结点，二叉树一定是有序的，二叉树可以为空（但树不能为空，至少要有1个结点）。

二、二叉树的性质：
性质1：在二叉树的第i层上至多有2i-1个结点（i>=1）。
性质2：深度为k的二叉树至多有2k –1个结点（k>=1）。
特别地，一棵深度为k且有2k –1个结点的二叉树称为满二叉树。图5是深度为4的满二叉树，这种树的特点是每层上的结点数都达到了最大值。

图5
可以对满二叉树的结点进行连续编号，约定编号从根结点起，自上而下，从左到右，由此引出完全二叉树的定义：深度为k，有n个结点的二叉树当且仅当其每一个结点都与深度为k的满二叉树中编号从1到n的结点一一对应时，称为完全二叉树。 如图6就是一个深度为4，结点数为12的完全二叉树。

图6
完全二叉树具有如下特征：叶结点只可能出现在最下面两层上；对任一结点，若其右子树深度为m，则其左子树的深度必为m或m+1。图7和图8所示的两棵二叉树就不是完全二叉树，请读者思考为什么？

图7 图8
性质3：对任何一棵二叉树，如果其叶结点数为n0，度为2的结点数为n2，则一定满足：n0=n2+1。
性质4：具有n个结点的完全二叉树的深度为trunc(LOG2n)+1 （trunc为取整函数）
性质5：一棵n个结点的完全二叉树，对于任一编号为i结点，有：
1．如果i=1,则结点i为根，无父结点；如果i>1,则其父结点编号为trunc(i/2)。
2．如果2*i>n，则结点i为叶结点；否则左孩子编号为2*i。
3．如果2*i+1>n，则结点i无右孩子；否则右孩子编号为2*i+1。

三、 二叉树的存储结构
二叉树的存储结构与普通树的存储结构基本相同，有链式和顺序存储两种方法。
1．链式存储结构:单链表结构或双链表结构，基本数据结构定义如下：
Type tree=^node； {单链表结构}
node=Record
data:Char； {数据域}
lchild,rchild:tree {指针域：分别指向左、右孩子}
End；
Var bt:tree；
Type tree=^node； {双链表结构}
node=Record
data:Char； {数据域}
lchild,rchild,father:tree {指针域：分别指向左、右孩子及父结点}
End；
Var bt:tree；
如图9左边所示的一棵二叉树用单链表就可以表示成右边的形式。
bt

图9
2．顺序存储结构:即几个数组加一个指针变量，一般用在满二叉树和完全二叉树中，将每个结点编号后作为数组的下标变量值，基本数据结构定义如下：
Const n=10； {最多10个结点}
Var data:Array[1..n] Of Char； {n个结点的数据域}
lchild:Array[1..n] Of Integer； {n个结点的左孩子}
rchild:Array[1..n] Of Integer； { n个结点的右孩子}
bt:Integer； {根结点指针}
这种结构可以很方便地从根结点往下遍历，但是如果想从某个分支结点或叶结点遍历整棵树，则还需设置一个父结点数组，操作也教麻烦。其实如果树的结点较少，也可采用邻接矩阵的方法，这样操作起来也很方便。
二叉树在处理表达式时经常用到，一般用叶结点表示运算数，分支结点表示运算符。这样的二叉树称为表达式树，如表达式（a+b/c）*(d-e)就可以表示成图10。
bt

图10
例2：医院设置
[问题描述] 设有一棵二叉树（如图11），其中圈中的数字表示结点中居民的人口，圈边上数字表示结点编号。现在要求在某个结点上建立一个医院，使所有居民所走的路程之和为最小，同时约定，相邻接点之间的距离为1。就本图而言，若医院建在1处，则距离和=4+12+2*20+2*40=136；若医院建在3处，则距离和=4*2+13+20+40=81……
[输入格式]
输入文件名为hospital.in，其中第一行一个整数n，表示树的结点数（n<=100）。接下来的n行每行描述了一个结点的状况，包含三个整数，整数之间用空格（一个或多个）分隔，其中：第一个数为居民人口数；第二个数为左链接，为0表示无链接；第三个数为右链接。
[输出格式]
输出文件名为hospital.out，该文件只有一个整数，表示最小距离和。

[样例输入]
5
13 2 3
4 0 0
12 4 5
20 0 0
40 0 0
[样例输出]
81

[问题分析] 这是一道简单的二叉树应用问题，问题中的结点数并不多，数据规模也不大，采用邻接矩阵存储，用Floyed法求出任意两结点之间的最短路径长，然后穷举医院可能建立的n个结点位置，找出一个最小距离的位置即可。当然也可以用双链表结构或带父结点信息的数组存储结构来解决，但实际操作稍微麻烦了一点。

[参考程序]
Program p2(Input, Output)；
Var a : Array [1..100] Of Longint；
g : Array [1..100, 1..100] Of Longint；
n, i, j, k, l, r, min, total : Longint；
Begin
Assign(Input, 'hospital.in')； Reset(Input)；
Assign(Output, 'hospital.in')； Rewrite(Output)；
Readln(n)；
For i := 1 To n Do 图11
For j := 1 To n Do
g[i][j] := 1000000；
For i := 1 To n Do {读入、初始化}
Begin
g[i][i] := 0；
Readln(a[i], l, r)；
If l > 0 Then Begin g[i][l] := 1；g[l][i] := 1 End；
If r > 0 Then Begin g[i][r] := 1；g[r][i] := 1 End；
End；
For k := 1 To n Do {用Floyed法求任意两结点之间的最短路径长}
For i := 1 To n Do
If i <> k Then
For j := 1 To n Do
If (i <> j) And (k <> j) And (g[i][k] + g[k][j] < g[i][j])
Then g[i][j] := g[i][k] + g[k][j]；
min := Maxlongint；
For i := 1 To n Do {穷举医院建在N个结点，找出最短距离}
Begin
total := 0；
For j := 1 To n Do
Inc(total, g[i][j] * a[j])；
If total < min Then min := total；
End；
Writeln(min)；
Close(Input)；Close(Output)；
End.

[后记] 在各种竞赛中经常遇到这样的问题：N-1条公路连接着N个城市，从每个城市出发都可以通过公路到达其它任意的城市。每个城市里面都有一定数量的居民，但是数量并不一定相等，每条公路的长度也不一定相等。X公司（或者是政府）决定在某一个城市建立一个医院/酒厂/游乐场……，问：将它建在哪里，可以使得所有的居民移动到那里的总耗费最小？这种题目都是本题的“变型”，一般称为“树的中心点问题”。除了简单的穷举法外，还有更好的时间复杂度为O(n)的算法，我们讲在后面的章节中继续讨论。

四、普通树转换成二叉树
由于二叉树是有序的，而且操作和应用更广泛，所以在实际使用时，我们经常把普通树转换成二叉树进行操作。如何转换呢？一般方法如下：
1．将树中每个结点除了最左边的一个分支保留外，其余分支都去掉；
2．从最左边结点开始画一条线，把同一层上的兄弟结点都连起来；
3．以整棵树的根结点为轴心，将整棵树顺时针大致旋转45度。

第一节中的图1所示的普通树转换成二叉树的过程如图12所示：

图12
同样我们可以把森林也转换成二叉树处理，假设F={T1，T2，…，Tm}是森林，则可按如下规则转换成一棵二叉树B=(root,lb,rb)。
1．若F为空，即m=0，则 B为空树；
2．若F非空，即m<>0，则B的根root即为森林中第一棵树的根root(T1)；B的左子树lb是从T1中根结点的子树森林F1={T11，T12，…，T1m1}转换而成的二叉树；其右子树rb是从森林F’ ={T2，T3，…，Tm}转换而成的二叉树。

五、二叉树的遍历
在二叉树的应用中，常常要求在树中查找具有某种特征的结点，或者对全部结点逐一进行某种处理,这就是二叉树的遍历问题。所谓二叉树的遍历是指按一定的规律和次序访问树中的各个结点，而且每个结点仅被访问一次。“访问”的含义很广，可以是对结点作各种处理，如输出结点的信息等。遍历方法共有3种：先序（根）遍历，中序（根）遍历， 图13
后序（根）遍历。下面以图13所示的二叉树为例分别讲解这3种方法。
1．先序遍历的操作定义如下：
若二叉树为空，则空操作，否则
① 访问根结点
② 先序遍历左子树
③ 先序遍历右子树
很明显，这是一种递归定义，下面给出一种手工方法（括号法）求先序遍历的结果。
={1，2，3，4，5，6，7，8，9} {所有结点}
={1，{2，4，5，7}，{3，6，8，9}} {按先序思想遍历，将根结点单独列出，左右子树分别用括号括起来}
={1，{2，{4，7}，{5}}，{3，{}，{6，8，9}}} {再对以2、3结点为根的树先序遍历}
={1，{2，{4，{7}，{}，5}，{3，{}，6，{8}，{9}}} {再对以4、5、6结点为根的树先序遍历，遇到无左、右子树的情况就用一对空括号，遇到叶子结点就脱到本层括号，遇到空括号就省略}
={1，2，4，7，5，3，6，8，9} {去掉内层所有括号，得到结果}
2．中序遍历的操作定义如下：
若二叉树为空，则空操作，否则
① 中序遍历左子树
② 访问根结点
③ 中序遍历右子树
可以根据以上方法，得出上图中序遍历的结果为：{7，4，2，5，1，3，8，6，9}
3．后序遍历的操作定义如下：
若二叉树为空，则空操作，否则
① 后序遍历左子树
② 后序遍历右子树
③ 访问根结点
可以根据以上方法，得出上图后序遍历的结果为：{7，4，5，2，8，9，6，3，1}

显然，以上3种遍历方法都是采用递归的思想，下面以先序遍历为例给出递归算法：
Procedure preorder(bt:tree)；{先序遍历根结点为bt的二叉树的递归算法}
Begin
If bt<>Nil Then Begin
Write(bt^.data)；
preorder(bt^.lchild)；
preorder(bt^.rchild)；
End；
End；

我们也可以把递归过程改成用栈实现的非递归过程，下面给出先序遍历的非递归过程。
Procedure inorder(bt:tree)； {先序遍历bt所指的二叉树}
Var stack:Array[1..n] Of tree； {栈}
top:integer； {栈顶指针}
p:tree；
Begin
top:=0；
While Not ((bt=Nil)And(top=0)) Do
Begin
While bt<>Nil Do Begin {非叶结点}
Write(bt^.data)； {访问根}
top:=top+1； {右子树压栈}
stack[top]:=bt^.rchild；
bt:=bt^.lchild； {遍历左子树}
End；
If top<>0 Then Begin {栈中所有元素出栈，遍历完毕}
b:=stack[top]；top:=top-1；
End；
End；
End；
关于前面讲的表达式树，我们可以分别用先序、中序、后
序的遍历方法得出完全不同的遍历结果，对于图14采用三种遍历后的结果如下，它们正好对应着表达式的三种表示方法：
-+a*b-cd/ef (前缀表示、波兰式)
a+b*c-d-e/f (中缀表示、代数式)
abcd-*+ef/- (后缀表示、逆波兰式)

图14
六、二叉树的其它重要操作：
除了“遍历”以外，二叉树的其它重要操作还有：建立一棵二叉树、插入一个结点到二叉树中、删除结点或子树等，下面分别给出基本算法框架。
1．建立一棵二叉树
Procedure pre_crt(Var bt:tree)；{按先序次序输入二叉树中结点的值，
Begin 生成二叉树的单链表存储结构}
Read(ch)；
If ch=’’ Then bt:=Nil {’’表示空树}
Else Begin
New(bt)； {建根结点}
bt^.data:=ch；
pre_crt(bt^.lchild)； {建左子树}
pre_crt(bt^.rchild)； {建右子树}
End；
End；

2．删除二叉树
Procedure dis(Var bt:tree)；
Begin
If bt<>Nil Then Begin
Dis(bt^.lchild)； {