下载文档原格式
二叉树知识点总结1. 二叉树的性质1.1 二叉树的性质一：二叉树的深度二叉树的深度是指从根节点到叶子节点的最长路径长度。
对于一个空树而言，它的深度为0；对于只有一个根节点的树而言，它的深度为1。
根据定义可知，深度为k的二叉树中，叶子节点的深度值为k。
由此可知，二叉树的深度为所有叶子节点深度的最大值。
1.2 二叉树的性质二：二叉树的高度二叉树的高度是指从根节点到叶子节点的最短路径长度。
对于一个空树而言，它的高度为0；对于只有一个根节点的树而言，它的高度为1。
由此可知，二叉树的高度总是比深度大一。
1.3 二叉树的性质三：二叉树的节点数量对于一个深度为k的二叉树而言，它最多包含2^k - 1个节点。
而对于一个拥有n个节点的二叉树而言，它的深度最多为log2(n+1)。
1.4 二叉树的性质四：满二叉树满二叉树是一种特殊类型的二叉树，它的每个节点要么是叶子节点，要么拥有两个子节点。
满二叉树的性质是：对于深度为k的满二叉树而言，它的节点数量一定是2^k - 1。
1.5 二叉树的性质五：完全二叉树完全二叉树是一种特殊类型的二叉树，它的所有叶子节点都集中在树的最低两层，并且最后一层的叶子节点从左到右依次排列。
对于一个深度为k的完全二叉树而言，它的节点数量一定在2^(k-1)和2^k之间。
2. 二叉树的遍历二叉树的遍历是指按照一定的顺序访问二叉树的所有节点。
二叉树的遍历主要包括前序遍历、中序遍历和后序遍历三种。
2.1 前序遍历（Pre-order traversal）前序遍历的顺序是：根节点 -> 左子树 -> 右子树。
对于一个二叉树而言，前序遍历的结果就是按照“根-左-右”的顺序访问所有节点。
2.2 中序遍历（In-order traversal）中序遍历的顺序是：左子树 -> 根节点 -> 右子树。
对于一个二叉树而言，中序遍历的结果就是按照“左-根-右”的顺序访问所有节点。
2.3 后序遍历（Post-order traversal）后序遍历的顺序是：左子树 -> 右子树 -> 根节点。
基本二叉树知识讲解一、有关二叉树的学习性质1：二叉树上叶子结点数等于度为2的结点数加1。
性质2：二叉树的第i层上至多有2的i次方减1个结点（i>=1）。
性质3：深度为h的二叉树至多有2的h次方减1个结点。
满二叉树：在一棵二叉树中，当第i层的结点树为2的i次方减1个时，称此层的结点数是满的。
当一棵二叉树中的每一层都满时，称此树为满二叉树。
特性：除叶子结点以外的其他的结点的度皆为2，且叶子结点在同一层上。
深度为h的满二叉树中的结点数为2的h次方减1。
性质4：设含有n个结点的完全二叉树的深度为k，则k=(int)(log2n)+1,即深度k等于log2n的整数部分再加1。
二叉树的存储结构1：顺序存储结构二叉树的顺序存储结构类型定义如下：#define TREEMINSIZE 10typedef struct{BTreeDT(数据类型) *base;int spacesize;BTreeDT nullvalue;}SeqTree;2：链式存储结构（一般的二叉树主要采用链式存储结构通常有二叉链表和三叉链表两种形式）1>二叉链表存储结构二叉链表中的每个结点由data，lchild和rchild三个域组成，定义如下：typedef struct bkbtnode{BTreeDT data;struct bkbtnode *lchild;struct bkbtnode *rchild;}BTNode,*BKBTree;在二叉链表中，查找某结点的孩子很容易实现，但查找某结点的双亲不方便。
一棵喊有n个结点的二叉树采用二叉链表存储时，将有2n-（n-1）=n+1个指针域是空的。
2>三叉链表存储结构typedef struct tkbtnode{BTreeDT data;struct tkbtnode *lchild;struct tkbtnode *rchild;struct tkbtnode *parent;}TKBTNode,*TKBTree;其中，parent域存放该结点双亲的指针。
数据结构之⼆叉树（BinaryTree）⽬录导读 ⼆叉树是⼀种很常见的数据结构，但要注意的是，⼆叉树并不是树的特殊情况，⼆叉树与树是两种不⼀样的数据结构。
⽬录 ⼀、⼆叉树的定义 ⼆、⼆叉树为何不是特殊的树 三、⼆叉树的五种基本形态 四、⼆叉树相关术语 五、⼆叉树的主要性质（6个） 六、⼆叉树的存储结构（2种） 七、⼆叉树的遍历算法（4种） ⼋、⼆叉树的基本应⽤：⼆叉排序树、平衡⼆叉树、赫夫曼树及赫夫曼编码⼀、⼆叉树的定义 如果你知道树的定义（有限个结点组成的具有层次关系的集合），那么就很好理解⼆叉树了。
定义：⼆叉树是n(n≥0)个结点的有限集，⼆叉树是每个结点最多有两个⼦树的树结构，它由⼀个根结点及左⼦树和右⼦树组成。
（这⾥的左⼦树和右⼦树也是⼆叉树）。
值得注意的是，⼆叉树和“度⾄多为2的有序树”⼏乎⼀样，但，⼆叉树不是树的特殊情形。
具体分析如下⼆、⼆叉树为何不是特殊的树 1、⼆叉树与⽆序树不同 ⼆叉树的⼦树有左右之分，不能颠倒。
⽆序树的⼦树⽆左右之分。
2、⼆叉树与有序树也不同（关键） 当有序树有两个⼦树时，确实可以看做⼀颗⼆叉树，但当只有⼀个⼦树时，就没有了左右之分，如图所⽰：三、⼆叉树的五种基本状态四、⼆叉树相关术语是满⼆叉树；⽽国际定义为，不存在度为1的结点，即结点的度要么为2要么为0，这样的⼆叉树就称为满⼆叉树。
这两种概念完全不同，既然在国内，我们就默认第⼀种定义就好）。
完全⼆叉树：如果将⼀颗深度为K的⼆叉树按从上到下、从左到右的顺序进⾏编号，如果各结点的编号与深度为K的满⼆叉树相同位置的编号完全对应，那么这就是⼀颗完全⼆叉树。
如图所⽰：五、⼆叉树的主要性质 ⼆叉树的性质是基于它的结构⽽得来的，这些性质不必死记，使⽤到再查询或者⾃⼰根据⼆叉树结构进⾏推理即可。
性质1：⾮空⼆叉树的叶⼦结点数等于双分⽀结点数加1。
证明：设⼆叉树的叶⼦结点数为X，单分⽀结点数为Y，双分⽀结点数为Z。
二叉树的几种基本形态二叉树是一种重要的数据结构，在计算机科学和数据结构领域有着广泛的应用。
它由节点和边组成，每个节点最多有两个子节点。
根据节点和边的组合方式，我们可以将二叉树分为几种基本形态。
一、满二叉树满二叉树是指一个二叉树的每个节点都有两个子节点，除了叶子节点。
叶子节点是指没有子节点的节点。
满二叉树是一种特殊的完全二叉树，它的深度为h，节点个数为2^h - 1。
满二叉树具有以下特点：1. 每个节点都有两个子节点，除了叶子节点；2. 所有叶子节点都在同一层；3. 每个非叶子节点都有两个子节点；4. 节点个数为2^h - 1，其中h为深度。
满二叉树的应用非常广泛，例如在堆排序中，堆通常就是满二叉树。
二、完全二叉树完全二叉树是指除了最后一层节点可能不满外，其他层节点都是满的二叉树。
在最后一层，所有的节点都集中在左边。
完全二叉树具有以下特点：1. 最后一层的节点都集中在左边；2. 其他层节点都是满的；3. 如果一个节点有右子节点，则一定有左子节点；4. 节点个数最少为2^(h-1)，最多为2^h - 1，其中h为深度。
完全二叉树的应用也非常广泛，例如在二叉堆中，堆通常就是完全二叉树。
三、二叉搜索树二叉搜索树是一种特殊的二叉树，它的左子树中所有节点的值都小于根节点的值，右子树中所有节点的值都大于根节点的值。
同样的规则也适用于每个子树。
二叉搜索树具有以下特点：1. 左子树中所有节点的值都小于根节点的值；2. 右子树中所有节点的值都大于根节点的值；3. 每个子树都符合上述规则；4. 不存在相同节点。
二叉搜索树的应用也非常广泛，例如在数据库中，索引通常就是基于二叉搜索树实现的。
四、平衡二叉树平衡二叉树也称为AVL树，它是一种特殊的二叉搜索树，它的左子树和右子树的高度差不超过1。
这种平衡可以保证二叉树的查找、插入、删除等操作的时间复杂度都是O(log n)。
平衡二叉树具有以下特点：1. 左子树和右子树的高度差不超过1；2. 每个子树都符合上述规则；3. 它是一种特殊的二叉搜索树。
平衡树——特点：所有结点左右子树深度差≤1排序树——特点：所有结点―左小右大字典树——由字符串构成的二叉排序树判定树——特点：分支查找树（例如12个球如何只称3次便分出轻重）带权树——特点：路径带权值（例如长度）最优树——是带权路径长度最短的树，又称Huffman树，用途之一是通信中的压缩编码。
1.1 二叉排序树：或是一棵空树；或者是具有如下性质的非空二叉树：（1）若左子树不为空，左子树的所有结点的值均小于根的值；（2）若右子树不为空，右子树的所有结点均大于根的值；（3）它的左右子树也分别为二叉排序树。
例：二叉排序树如图9.7：二叉排序树的查找过程和次优二叉树类似，通常采取二叉链表作为二叉排序树的存储结构。
中序遍历二叉排序树可得到一个关键字的有序序列，一个无序序列可以通过构造一棵二叉排序树变成一个有序序列，构造树的过程即为对无序序列进行排序的过程。
每次插入的新的结点都是二叉排序树上新的叶子结点，在进行插入操作时，不必移动其它结点，只需改动某个结点的指针，由空变为非空即可。
搜索,插入,删除的复杂度等于树高，期望O(logn),最坏O(n)(数列有序,树退化成线性表).虽然二叉排序树的最坏效率是O(n),但它支持动态查询,且有很多改进版的二叉排序树可以使树高为O(logn),如SBT,AVL,红黑树等.故不失为一种好的动态排序方法.2.2 二叉排序树b中查找在二叉排序树b中查找x的过程为：1. 若b是空树，则搜索失败，否则：2. 若x等于b的根节点的数据域之值，则查找成功；否则：3. 若x小于b的根节点的数据域之值，则搜索左子树；否则：4. 查找右子树。
[cpp]view plaincopyprint?1.Status SearchBST(BiTree T, KeyType key, BiTree f, BiTree &p){2. //在根指针T所指二叉排序樹中递归地查找其关键字等于key的数据元素，若查找成功，3. //则指针p指向该数据元素节点，并返回TRUE，否则指针P指向查找路径上访问的4. //最好一个节点并返回FALSE，指针f指向T的双亲，其初始调用值为NULL5. if(!T){ p=f; return FALSE;} //查找不成功6. else if EQ(key, T->data.key) {P=T; return TRUE;} //查找成功7. else if LT(key,T->data.key)8. return SearchBST(T->lchild, key, T, p); //在左子树继续查找9. else return SearchBST(T->rchild, key, T, p); //在右子树继续查找10.}2.3 在二叉排序树插入结点的算法向一个二叉排序树b中插入一个结点s的算法，过程为：1. 若b是空树，则将s所指结点作为根结点插入，否则：2. 若s->data等于b的根结点的数据域之值，则返回，否则：3. 若s->data小于b的根结点的数据域之值，则把s所指结点插入到左子树中，否则：4. 把s所指结点插入到右子树中。
第一种方法，就是利用递归的方法，按层进行打印，我们把根节点当做第0层，之后层次依次增加，如果我们想打印第二层怎么办呢，利用递归的代码如下：
1.int print_at_level(Tree T, int level) {
2.if (!T || level < 0)
3.return 0;
4.if (0 == level) {
5.cout << T->data << " ";
6.return 1;
7.}
8.return print_at_level(T->lchild, level - 1) + pri
nt_at_level(T->rchild, level - 1);
9.}
第二种方法：我们可以设置两个队列，想象一下队列的特点，就是先进先出，首先把第0层保存在一个队列中，然后按节点访问，并把已经访问节点的左右孩子节点放在第二个队列中，当第一个队列中的所有节点都访问完成之后，交换两个节点
1.void print_by_level_2(Tree T) {
2.deque<tree_node_t*> q_first, q_second;
3.q_first.push_back(T);
4.while(!q_first.empty()) {
5.while (!q_first.empty()) {
6.tree_node_t *temp = q_first.front();
7.q_first.pop_front();
8.cout << temp->data << " ";
9.if (temp->lchild)
10. q_second.push_back(temp->lchild
);
11. if (temp->rchild)
12. q_second.push_back(temp->rchild
);
13. }
14. cout << endl;
15. q_first.swap(q_second);
16. }
17.}
第三种方法就是设置双指针，一个指向访问当层开始的节点，一个指向访问当层结束节点的下一个位置：
这是第一层访问的情况，当访问第0层之后的结构如下，把第0层的所有子节点加入之后：
访问完第1层之后：
完整代码如下：
ing namespace std;
2.
3.typedef struct tree_node_s {
4.char data;
5.struct tree_node_s *lchild;
6.struct tree_node_s *rchild;
7.}tree_node_t, *Tree;
8.
9.void create_tree(Tree *T) {
10. char c = getchar();
11. if (c == '#') {
12. *T = NULL;
13. } else {
14. *T = (tree_node_t*)malloc(sizeof(tree_node_t)
);
15. (*T)->data = c;
16. create_tree(&(*T)->lchild);
17. create_tree(&(*T)->rchild);
18. }
19.}
20.
21.void print_tree(Tree T) {
22. if (T) {
23. cout << T->data << " ";
24. print_tree(T->lchild);
25. print_tree(T->rchild);
26. }
27.}
28.int print_at_level(Tree T, int level) {
29. if (!T || level < 0)
30. return 0;
31. if (0 == level) {
32. cout << T->data << " ";
33. return 1;
34. }
35. return print_at_level(T->lchild, level - 1) + pri
nt_at_level(T->rchild, level - 1);
36.}
37.
38.void print_by_level_1(Tree T) {
39. int i = 0;
40. for (i = 0; ; i++) {
41. if (!print_at_level(T, i))
42. break;
43. }
44. cout << endl;
45.}
46.
47.void print_by_level_2(Tree T) {
48. deque<tree_node_t*> q_first, q_second;
49. q_first.push_back(T);
50. while(!q_first.empty()) {
51. while (!q_first.empty()) {
52. tree_node_t *temp = q_first.front();
53. q_first.pop_front();
54. cout << temp->data << " ";
55. if (temp->lchild)
56. q_second.push_back(temp->lchild
);
57. if (temp->rchild)
58. q_second.push_back(temp->rchild
);
59. }
60. cout << endl;
61. q_first.swap(q_second);
62. }
63.}
64.
65.void print_by_level_3(Tree T) {
66. vector<tree_node_t*> vec;
67. vec.push_back(T);
68. int cur = 0;
69. int end = 1;
70. while (cur < vec.size()) {
71. end = vec.size();
72. while (cur < end) {
73. cout << vec[cur]->data << " ";
74. if (vec[cur]->lchild)
75. vec.push_back(vec[cur]->lchild)
;
76. if (vec[cur]->rchild)
77. vec.push_back(vec[cur]->rchild)
;
78. cur++;
79. }
80. cout << endl;
81. }
82.}
83.
84.int main(int argc, char *argv[]) {
85. Tree T = NULL;
86. create_tree(&T);
87. print_tree(T);
88. cout << endl;
89. print_by_level_3(T);
90. cin.get();
91. cin.get();
92. return 0;
93.}。
