《算法导论》读书笔记之第10章 基本数据结构之二叉树.docx
《《算法导论》读书笔记之第10章 基本数据结构之二叉树.docx》由会员分享，可在线阅读，更多相关《《算法导论》读书笔记之第10章 基本数据结构之二叉树.docx（17页珍藏版）》请在冰豆网上搜索。
《算法导论》读书笔记之第10章基本数据结构之二叉树
《算法导论》读书笔记之第10章基本数据结构之二叉树
摘要
书中第10章10.4小节介绍了有根树，简单介绍了二叉树和分支数目无限制的有根树的存储结构，而没有关于二叉树的遍历过程。
为此对二叉树做个简单的总结，介绍一下二叉树基本概念、性质、二叉树的存储结构和遍历过程，主要包括先根遍历、中根遍历、后根遍历和层次遍历。
1、二叉树的定义
二叉树（BinaryTree）是一种特殊的树型结构，每个节点至多有两棵子树，且二叉树的子树有左右之分，次序不能颠倒。
由定义可知，二叉树中不存在度（结点拥有的子树数目）大于2的节点。
二叉树形状如下下图所示：
2、二叉树的性质
（1）在二叉树中的第i层上至多有2^（i-1）个结点（i>=1）。
备注:
^表示此方
（2）深度为k的二叉树至多有2^k-1个节点（k>=1）。
（3）对任何一棵二叉树T，如果其终端结点数目为n0，度为2的节点数目为n2，则n0=n2+1。
满二叉树：
深度为k且具有2^k-1个结点的二叉树。
即满二叉树中的每一层上的结点数都是最大的结点数。
完全二叉树：
深度为k具有n个结点的二叉树，当且仅当每一个结点与深度为k的满二叉树中的编号从1至n的结点一一对应。
可以得到一般结论：
满二叉树和完全二叉树是两种特殊形态的二叉树，满二叉树肯定是完全二叉树，但完全二叉树不不一定是满二叉树。
举例如下图是所示：
（4）具有n个节点的完全二叉树的深度为log2n+1。
3、二叉树的存储结构
可以采用顺序存储数组和链式存储二叉链表两种方法来存储二叉树。
经常使用的二叉链表方法，因为其非常灵活，方便二叉树的操作。
二叉树的二叉链表存储结构如下所示：
1typedefstructbinary_tree_node
2{
3intelem;
4structbinary_tree_node*left;
5structbinary_tree_node*right;
6}binary_tree_node,*binary_tree;
举例说明二叉链表存储过程，如下图所示：
从图中可以看出：
在还有n个结点的二叉链表中有n+1个空链域。
4、遍历二叉树
遍历二叉树是按照指定的路径方式访问书中每个结点一次，且仅访问一次。
由二叉树的定义，我们知道二叉数是由根结点、左子树和右子树三部分构成的。
通常遍历二叉树是从左向右进行，因此可以得到如下最基本的三种遍历方法：
（1）先根遍历（先序遍历）：
如果二叉树为空，进行空操作；否则，先访问根节点，然后先根遍历左子树，最后先根遍历右子树。
采用递归形式实现代码如下：
1voidpreorder_traverse_recursive（binary_treeroot）
2{
3if（NULL!
=root）
4{
5printf（"%d\t",root->elem）;
6preorder_traverse_recursive（root->left）;
7preorder_traverse_recursive（root->right）;
8}
9}
具体过程如下图所示：
（2）中根遍历（中序遍历）：
如果二叉树为空，进行空操作；否则，先中根遍历左子树，然后访问根结点，最后中根遍历右子树。
递归过程实现代码如下：
1voidinorder_traverse_recursive（binary_treeroot）
2{
3if（NULL!
=root）
4{
5inorder_traverse_recursive（root->left）;
6printf（"%d\t",root->elem）;
7inorder_traverse_recursive（root->right）;
8}
9}
具体过程如下图所示：
（3）后根遍历（后序遍历）：
如果二叉树为空，进行空操作；否则，先后根遍历左子树，然后后根遍历右子树，最后访问根结点。
递归实现代码如下：
1voidpostorder_traverse_recursive（binary_treeroot）
2{
3if（NULL!
=root）
4{
5postorder_traverse_recursive（root->left）;
6postorder_traverse_recursive（root->right）;
7printf（"%d\t",root->elem）;
8}
9}
具体过程如下图所示：
写一个完整的程序练习二叉树的三种遍历，采用递归形式创建二叉树，然后以递归的形式遍历二叉树，后面会接着讨论如何使用非递归形式实现这三种遍历，程序采用C语言实现，完整程序如下：
1#include<stdio.h>
2#include<stdlib.h>
3
4//thestructureofbinarytree
5typedefstructbinary_tree_node
6{
7intelem;
8structbinary_tree_node*left;
9structbinary_tree_node*right;
10}binary_tree_node,*binary_tree;
11
12voidinit_binary_tree（binary_tree*root）;
13voidcreate_binary_tree（binary_tree*root）;
14
15//previousroot
16voidpreorder_traverse_recursive（binary_treeroot）;
17//inorderroot
18voidinorder_traverse_recursive（binary_treeroot）;
19//postorderroot
20voidpostorder_traverse_recursive（binary_treeroot）;
21
22intmain（）
23{
24binary_treeroot;
25init_binary_tree（&root）;
26create_binary_tree（&root）;
27preorder_traverse_recursive（root）;
28inorder_traverse_recursive（root）;
29postorder_traverse_recursive（root）;
30exit（0）;
31}
32
33voidinit_binary_tree（binary_tree*root）
34{
35*root=NULL;
36}
37
38voidcreate_binary_tree（binary_tree*root）
39{
40intelem;
41printf（"Enterthenodevalue（0isend）:
"）;
42scanf（"%d",&elem）;
43if（elem==0）
44*root=NULL;
45else
46{
47*root=（binary_tree）malloc（sizeof（binary_tree_node））;
48if（NULL==root）
49{
50printf（"mallocerror.\n"）;
51exit（-1）;
52}
53（*root）->elem=elem;
54printf（"Creatingtheleftchildnode.\n"）;
55create_binary_tree（&（（*root）->left））;
56printf（"Createingtherightchildnode.\n"）;
57create_binary_tree（&（（*root）->right））;
58}
59}
60
61voidpreorder_traverse_recursive（binary_treeroot）
62{
63if（NULL!
=root）
64{
65printf（"%d\t",root->elem）;
66preorder_traverse_recursive（root->left）;
67preorder_traverse_recursive（root->right）;
68}
69}
70
71voidinorder_traverse_recursive（binary_treeroot）
72{
73if（NULL!
=root）
74{
75inorder_traverse_recursive（root->left）;
76printf（"%d\t",root->elem）;
77inorder_traverse_recursive（root->right）;
78}
79}
80
81voidpostorder_traverse_recursive（binary_treeroot）
82{
83if（NULL!
=root）
84{
85postorder_traverse_recursive（root->left）;
86postorder_traverse_recursive（root->right）;
87printf（"%d\t",root->elem）;
88}
89}
程序测试结果如下：
现在来讨论一下如何采用非递归实现这以上三种遍历。
将递归形式转换为非递归形式，引入了额外的辅助结构栈。
另外在讨论一次二叉树的层次遍历，可以借助队列进行实现。
具体讨论如下：
（1）先根遍历非递归实现
先根遍历要求顺序是根左右，可以借助栈s来实现。
先将根root入栈，然后循环判断s是否为空，非空则将结点出栈，记为节点p，然后依次先将结点p的右子树结点入栈，然后将结点p的左子树结点入栈，循环操作直到栈中所有元素都出栈为止，出栈顺序即是先根遍历的结果。
采用C++中模板库stack实现先根遍历如下：
1voidpreorder_traverse（binary_treeroot）
2{
3if（NULL!
=root）
4{
5stack<binary_tree_node*>s;
6binary_tree_node*ptmpnode;
7s.push（root）;
8while（!
s.empty（））
9{
10ptmpnode=s.top（）;
11cout<<ptmpnode->elem<<"";
12s.pop（）;
13if（NULL!
=ptmpnode->right）
14s.push（ptmpnode->right）;
15if（NULL!
=ptmpnode->left）
16s.push（ptmpnode->left）;
17
18}
19}
20}
（2）中根遍历非递归实现
中根遍历要求顺序是左根右，借助栈s实现。
先将根root入栈，接着从根root开始查找最左的子孩子结点直到为空为止，然后将空节点出栈，再将左子树节点出栈遍历，然后判断该左子树的右子树节点入栈。
循环此过程，直到栈为空为止。
此时需要注意的是入栈过程中空结点也入栈了，用以判断左孩子是否结束和左孩子是否有右孩子结点。
采用C++中模板库stack实现先根遍历如下：
1voidinorder_traverse（binary_treeroot）
2{
3if（NULL!
=root）
4{
5stack<binary_tree_node*>s;
6binary_tree_node*ptmpnode;
7s.push（root）;
8while（!
s.empty（））
9{
10ptmpnode=s.top（）;
11while（NULL!
=ptmpnode）
12{
13s.push（ptmpnode->left）;
14ptmpnode=s.top（）;
15}
16s.pop（）;//空结点出栈
17if（!
s.empty（））
18{
19ptmpnode=s.top（）;
20cout<<ptmpnode->elem<<"";
21s.pop（）;
22//右子树结点如栈
23s.push（ptmpnode->right）;
24}
25}
26}
27}
另外一种简洁的实现方法如下：
1voidinorder_traverse_two（binary_treeroot）
2{
3if（NULL!
=root）
4{
5stack<binary_tree_node*>s;
6binary_tree_node*ptmpnode;
7ptmpnode=root;
8while（NULL!
=ptmpnode||!
s.empty（））
9{
10//将左子树结点入栈
11if（NULL!
=ptmpnode）
12{
13s.push（ptmpnode）;
14ptmpnode=ptmpnode->left;
15}
16else
17{
18//出栈遍历
19ptmpnode=s.top（）;
20s.pop（）;
21cout<<ptmpnode->elem<<"";
22//右子树结点
23ptmpnode=ptmpnode->right;
24}
25}
26}
27}
（3）后根遍历递归实现
后根遍历要求访问顺序是左右根，采用辅助栈实现时，需要一个标记，判断结点是否访问了，因为右子树是通过跟结点的信息得到的。
实现过程是先将根结点及其左子树入栈，并初始标记为0，表示没有访问，然后通过判断栈是否为空和标记的值是否为1来判断是否访问元素。
参考：
采用C++模板库stack具体实现程序如下：
1voidpostorder_traverse（binary_treeroot）
2{
3if（NULL!
=root）
4{
5stack<binary_tree_node*>s;
6binary_tree_node*ptmpnode;
7intflags[100];
8ptmpnode=root;
9while（NULL!
=ptmpnode||!
s.empty（））
10{
11//将结点左子树结点入栈
12while（NULL!
=ptmpnode）
13{
14s.push（ptmpnode）;
15flags[s.size（）]=0;//标记未访问
16ptmpnode=ptmpnode->left;
17}
18//输出访问的结点
19while（!
s.empty（）&&flags[s.size（）]==1）
20{
21ptmpnode=s.top（）;
22s.pop（）;
23cout<<ptmpnode->elem<<"";
24}
25//从右子树开始遍历
26if（!
s.empty（））
27{
28ptmpnode=s.top（）;
29flags[s.size（）]=1;//登记访问了
30ptmpnode=ptmpnode->right;
31}
32else
33break;
34}
35}
36}
（4）层次遍历实现
层次遍历要求从根向下、从左向右进行访问，可以采用队列实现。
先将根入队，然后队列进程出队操作访问结点p，再将结点p的左子树和右子树结点入队，循环执行此过程直到队列为空。
出队顺序即是层次遍历结果。
采用C++的模板库queue实现如下：
1voidlevelorder_traverse（binary_treeroot）
2{
3if（NULL!
=root）
4{
5queue<binary_tree_node*>q;
6binary_tree_node*ptmpnode;
7q.push（root）;
8while（!
q.empty（））
9{
10ptmpnode=q.front（）;
11q.pop（）;
12cout<<ptmpnode->elem<<"";
13if（NULL!
=ptmpnode->left）
14q.push（ptmpnode->left）;
15if（NULL!
=ptmpnode->right）
16q.push（ptmpnode->right）;
17}
18}
19}
综合上面的分析过程写个完整的程序测试二叉树遍历的非递归实现，采用C++语言，借助stack和queue实现，完整程序如下所示：
1#include<iostream>
2#include<stack>
3#include<queue>
4#include<cstdlib>
5usingnamespacestd;
6
7typedefstructbinary_tree_node
8{
9intelem;
10structbinary_tree_node*left;
11structbinary_tree_node*right;
12}binary_tree_node,*binary_tree;
13
14voidinit_binary_tree（binary_tree*root）;
15voidcreate_binary_tree（binary_tree*root）;
16voidpreorder_traverse（binary_treeroot）;
17voidinorder_traverse（binary_treeroot）;
18voidinorder_traverse_two（binary_treeroot）;
19voidpostorder_traverse（binary_treeroot）;
20voidlevelorder_traverse（binary_treeroot）;
21
22intmain（）
23{
24binary_treeroot;
25create_binary_tree（&root）;
26cout<<"preodrertraverse:
";
27preorder_traverse（root）;
28cout<<"\ninodrertraverse:
";
29inorder_traverse_two（root）;
30cout<<"\npostodrertraverse:
";
31postorder_traverse（root）;
32cout<<"\nleverordertraverse:
";
33levelorder_traverse（root）;
34exit（0）;
35}
36
37voidinit_binary_tree（binary_tree*root）
38{
39*root=NULL;
40}
41
42voidcreate_binary_tree（binary_tree*root）
43{
44intelem;
45cout<<"Enterthenodevalue（0isend）:
";
46cin>>elem;
47if（elem==0）
48*root=NULL;
49else
50{
51*root=（binary_tree）malloc（sizeof（binary_tree_node））;
52if（NULL==root）
53{
54cout<<"mallocerror.\n";
55exit（-1）;
56}
57（*root）->elem=elem;
58cout<<"Creatingtheleftchildnode.\n";
59create_binary_tree（&（（*root）->left））;
60cout<<"Createingtherightchildnode.\n";
61create_binary_tree（&（（*root）->right））;
62}
63}
64
65voidpreorder_traverse（binary_treeroot）
66{
67if（NULL!
=root）
68{
69stack<binary_tree_node*>s;
70binary_tree_node*ptmpnode;
71s.push（root）;
72while（!
s.empty（））
73{
74ptmpnode=s.top（）;
75cout<<ptmpnode->elem<<"";
76s.pop（）;
77if（NULL!
=ptmpnode->right）
78s.push（ptmpnode->right）;
79if（NULL!
=ptmpnode->left）
80s.push（ptmpnode->left）;
81
82}
83}
84}
升级会员 