二叉排序树或者是一棵空树;或者是具有如下特征的二叉树:若它的左子树不空,则左子树上所有结点的值均小于根结点的值;若它的右子树不空,则右子树上所有结点的值均大于根结点的值;它的左右子树也都分别是二叉排序树;二叉排序树的定义,是一个递归定义的过程;对二叉排序树进行中序遍历,遍历结果恰好是一个有序的线性序列,这也是它被称为二叉排序树的由来;
二叉排序树的查找,若给定值等于根结点的关键字,则查找成功;如果给定值小于根结点的关键字,则继续在左子树上进行查找;若给定值大于根结点的关键字,则继续在右子树上进行查找;若二叉排序树为空则查找失败;查找成功的路径,从根结点出发,沿着左分支或右分支逐层向下直至关键字等于给定值的结点;查找不成功的路径,从根结点出发,沿着左分支或右分支逐层向下直至指针指向空树为止;
二叉排序树插入结点的位置,就是查找失败的位置;插入操作在查找不成功时才进行,如果二叉排序树为空树,则新插入的结点为新的根结点;否则,新插入的结点必为一个新的叶子结点,其插入位置由查找过程得到;
二叉排序树,是在插入的基础上生成的,二叉排序树的生成过程就是结点序列的插入过程;二叉排序树的形态完全由一个输入序列决定,一个无序序列可以通过构造一棵二叉排序树而得到一个有序序列;
中序遍历二叉排序树可以得到关键字有序序列;在构造二叉排序树时,每次插入的新结点都是新的叶子结点,所以进行插入时不必移动其他结点;二叉排序树不但拥有类似于折半查找的特性,又采取了链表作为存储结构,因此是动态查找表的一种适宜表示;
二叉排序树的删除和插入相反,删除在查找成功之后进行,并且要求在删除二叉排序树上某个结点之后,仍然保持二叉排序树的特性;删除结点分三种情况,结点有左右二个孩子,有左孩子没有右孩子,有右孩子没有左孩子,左右孩子都没有;查找不到删除的结点删除不成功;被删除结点为叶子结点即没有左右孩子,修改其父结点的指针域就可以了,即该结点的指针赋值为NULL;被删除结点有左或右一个孩子的,修改其父结点的指针域,即该结点的指针由其子结点指针覆盖;被删除结点有左右两个孩子的,查找其右子树的最小值结点,右子树的最小值结点的值赋值给该结点,删除右子树的最小值结点,或者查找其左子树的最大值的结点,左子树的最大值结点的值赋值给该结点,删除左子树的最大值结点;
一、排序树操作集
1 #include <stdio.h>
2 #include <stdlib.h>
3
4 typedef int ElementType;
5 typedef struct TNode *Position;
6 typedef Position BinTree;
7 struct TNode
8 {
9 ElementType Data;
10 BinTree Left;
11 BinTree Right;
12 };
13
14 void PreorderTraversal( BinTree BT );
15 void InorderTraversal( BinTree BT );
16
17 BinTree Insert( BinTree BST, ElementType X );
18 BinTree Delete( BinTree BST, ElementType X );
19 Position Find( BinTree BST, ElementType X );
20 Position FindMin( BinTree BST );
21 Position FindMax( BinTree BST );
22
23
24 int main()
25 {
26 BinTree BST, MinP, MaxP, Tmp;
27 ElementType X;
28 int N, i;
29
30 BST = NULL;
31 scanf("%d", &N);
32 for ( i=0; i<N; i++ )
33 {
34 scanf("%d", &X);
35 BST = Insert(BST, X);
36 }
37 printf("Preorder:");
38 PreorderTraversal(BST);
39 printf("\n");
40 MinP = FindMin(BST);
41 MaxP = FindMax(BST);
42 scanf("%d", &N);
43 for( i=0; i<N; i++ )
44 {
45 scanf("%d", &X);
46 Tmp = Find(BST, X);
47 if (Tmp == NULL) printf("%d is not found\n", X);
48 else
49 {
50 printf("%d is found\n", Tmp->Data);
51 if (Tmp==MinP) printf("%d is the smallest key\n", Tmp->Data);
52 if (Tmp==MaxP) printf("%d is the largest key\n", Tmp->Data);
53 }
54 }
55 scanf("%d", &N);
56 for( i=0; i<N; i++ )
57 {
58 scanf("%d", &X);
59 BST = Delete(BST, X);
60 }
61 printf("Inorder:");
62 InorderTraversal(BST);
63 printf("\n");
64
65 return 0;
66 }
67
68 // 插入
69 BinTree Insert( BinTree BST, ElementType X )
70 {
71 if(!BST) // 如果为空,创建新结点
72 {
73 BST = (BinTree)malloc(sizeof(struct TNode));
74 BST->Data = X;
75 BST->Left = NULL;
76 BST->Right = NULL;
77 }
78 else
79 {
80 if(X < BST->Data)
81 BST->Left = Insert(BST->Left,X);
82 else if(BST->Data < X)
83 BST->Right = Insert(BST->Right,X);
84 }
85 return BST;
86 }
87
88 // 删除
89 BinTree Delete( BinTree BST, ElementType X )
90 {
91 BinTree tmp;
92 if(!BST)
93 {
94 printf("Not Found\n");
95 return BST;
96 }
97 else
98 {
99 if(X < BST->Data)
100 BST->Left = Delete(BST->Left,X);
101 else if(BST->Data < X)
102 BST->Right = Delete(BST->Right,X);
103 else // 找到要删除结点
104 {
105 if(BST->Left && BST->Right) // 如果该结点有左右儿子
106 {
107 tmp = FindMin(BST->Right);
108 BST->Data = tmp->Data;
109 BST->Right = Delete(BST->Right,tmp->Data);
110 }
111 else
112 {
113 tmp = BST;
114 if(BST->Left && !BST->Right)
115 BST = BST->Left;
116 else if(!BST->Left && BST->Right)
117 BST = BST->Right;
118 else
119 BST = NULL;
120 free(tmp);
121 }
122 }
123 }
124 return BST;
125 }
126
127 // 寻找值最小结点
128 Position FindMin( BinTree BST )
129 {
130 if(BST)
131 while(BST->Left)
132 BST = BST->Left;
133 return BST;
134 }
135
136 // 寻找值最大结点
137 Position FindMax( BinTree BST )
138 {
139 if(BST)
140 while(BST->Right)
141 BST = BST->Right;
142 return BST;
143 }
144
145 // 查找
146 Position Find( BinTree BST, ElementType X )
147 {
148 if(!BST)
149 {
150 return NULL;
151 }
152 else if(X < BST->Data)
153 return Find(BST->Left,X);
154 else if(BST->Data < X)
155 return Find(BST->Right,X);
156 else
157 return BST;
158 }
159
160 // 先序遍历
161 void PreorderTraversal( BinTree BT )
162 {
163 if(BT)
164 {
165 printf(" %d",BT->Data);
166 PreorderTraversal(BT->Left);
167 PreorderTraversal(BT->Right);
168 }
169 }
170 // 中序遍历
171 void InorderTraversal( BinTree BT )
172 {
173 if(BT)
174 {
175
176 InorderTraversal(BT->Left);
177 printf(" %d",BT->Data);
178 InorderTraversal(BT->Right);
179 }
180 }
二、判断是否同一棵排序树
1 #include <stdio.h>
2 #include <malloc.h>
3 /* 树结点定义 */
4 typedef struct TreeNode *Tree;
5 struct TreeNode {
6 int v;
7 Tree Left, Right;
8 int flag; /* 判别结点是否访问过的标记 */
9 };
10
11 /* 函数声明
12 1.创建一个树结点
13 2.插入一个树结点
14 3.创建一棵树
15 4.检查树结点是否访问过
16 5.判断是否同一棵树
17 6.清除树中各结点的flag标记
18 7.释放树的空间
19 */
20 Tree NewNode( int V );
21 Tree Insert( Tree T, int V );
22 Tree MakeTree( int N );
23 int check ( Tree T, int V );
24 int Judge( Tree T, int N );
25 void ResetT ( Tree T );
26 void FreeTree ( Tree T );
27
28 /* 主程序 */
29 int main()
30 {
31 int N, L, i;
32 Tree T; /* 创建一个树的空结点 */
33 scanf("%d", &N);
34 while (N)
35 {
36 scanf("%d", &L);
37 T = MakeTree(N); /* 创建一棵N个结点的树 */
38 for (i=0; i<L; i++)
39 { /* 判断是否同一棵树 */
40 if (Judge(T, N)) printf("Yes\n");
41 else printf("No\n");
42 ResetT(T); /*清除T中的标记flag*/
43 }
44 FreeTree(T); /* 释放上面的树空间 */
45 scanf("%d", &N);
46 }
47 return 0;
48 }
49 /* 创建一个树结点 */
50 Tree NewNode( int V )
51 {
52 Tree T = (Tree)malloc(sizeof(struct TreeNode));
53 T->v = V;
54 T->Left = T->Right = NULL;
55 T->flag = 0;
56 return T;
57 }
58 /* 插入一个树结点 */
59 Tree Insert( Tree T, int V )
60 {
61 if ( !T ) T = NewNode(V);
62 else
63 {
64 if ( V > T->v )
65 T->Right = Insert( T->Right, V );
66 else
67 T->Left = Insert( T->Left, V );
68 }
69 return T;
70 }
71 /* 创建一棵N个结点的树 */
72 Tree MakeTree( int N )
73 {
74 Tree T;
75 int i, V;
76 scanf("%d", &V);
77 T = NewNode(V); /* */
78 for (i=1; i<N; i++)
79 {
80 scanf("%d", &V);
81 T = Insert(T, V); /* */
82 }
83 return T;
84 }
85 /* 判断树的结点是否访问过 */
86 int check ( Tree T, int V )
87 {
88 if ( T->flag )
89 {
90 if ( V<T->v ) return check(T->Left, V);
91 else if ( V>T->v ) return check(T->Right, V);
92 else return 0;
93 }
94 else
95 {
96 if ( V==T->v )
97 {
98 T->flag = 1;
99 return 1;
100 }
101 else return 0;
102 }
103 }
104 /* 判断是否同一棵树 */
105 int Judge( Tree T, int N )
106 {
107 int i, V, flag = 0;
108 /* flag, 0代表目前还一致, 1代表已经不一致*/
109 scanf("%d", &V);
110 if ( V!=T->v ) flag = 1;
111 else T->flag = 1;
112 for (i=1; i<N; i++)
113 {
114 scanf("%d", &V);/* 读取结点的V */
115 if ( (!flag) && (!check(T, V)) ) flag = 1;
116 }
117 return !flag; /* 1代表已经不一致 */
118 }
119 /* 清除T中各结点的flag标记 */
120 void ResetT ( Tree T )
121 {
122 if (T->Left) ResetT(T->Left);
123 if (T->Right) ResetT(T->Right);
124 T->flag = 0;
125 }
126 /* 释放T的空间 */
127 void FreeTree ( Tree T )
128 {
129 if (T->Left) FreeTree(T->Left);
130 if (T->Right) FreeTree(T->Right);
131 free(T);
132 }
133
134 /*
135 测试用例
136 4 2
137 3 1 4 2
138 3 4 1 2
139 3 2 4 1
140 2 1
141 2 1
142 1 2 0
143 */
三、排序树非递归操作
1 Position IterFind( ElementType X, BinTree BST )
2 {
3 while( BST )
4 {
5 if( X > BST->Data )
6 BST = BST->Right; /*向右子树中移动,继续查找*/
7 else if( X < BST->Data )
8 BST = BST->Left; /*向左子树中移动,继续查找*/
9 else /* X == BST->Data */
10 return BST; /*查找成功,返回结点的找到结点的地址*/
11 }
12 return NULL; /*查找失败*/
13 }
1 BinTree Delete( BinTree BST, KeyType Key )
2 {
3 BinTree P,F,S,Q;
4 P = BST;
5 F = NULL; /* P的前驱结点指针 */
6
7 while(P)
8 {
9 if(P->Data == Key) /* 找到了 */
10 break;
11 F = P; /* 保存P指针 */
12 if(P->Data > Key)
13 P = P->Left; /* 左子树找 */
14 else
15 P = P->Right; /* 右子树找 */
16 }
17
18 if(P == NULL) /* 没找到返回 */
19 return BST;
20
21 if(P->Left == NULL) /* 删除结点的左子树为空 */
22 {
23 if(F == NULL) /* 如果删除的是根结点 */
24 BST = P->Right; /* P的右子树指针赋值给根结点指针 */
25 else if(F->Left == P) /* 如果删除结点是其父结点的左孩子 */
26 F->Left = P->Right;/* 删除结点的右孩子指针赋值给其父结点的左孩子 */
27 else
28 F->Right = P->Right;
29 free(P); /* 删除结点 */
30 }
31 else
32 {
33 Q = P; /* P指针赋值给Q */
34 S = P->Left; /* P的左孩子指针赋值给S */
35 while(S->Right) /* 向右找右子树的最大值S->Data */
36 {
37 Q = S; /* Q为S的前驱结点 */
38 S = S->Right;
39 }
40 if(Q == P) /* 如果P左子树S的右子树为空 */
41 Q->Left = S->Left;
42 else
43 Q->Right = S->Left;
44 P->Data = S->Data;
45 free(S);
46 }
47 return BST;
48 }
四、平衡二叉树
平衡因子(Balance Factor,简称BF): BF(T) = hL-hR,其中hL和hR分别为T的左、右子树的高度;平衡二叉树Balanced Binary Tree,AVL树 : 空树,或者任一结点左、右子树高度差的绝对值不超过1,即|BF(T) |≤ 1 ;给定结点数为 n 的AVL树的 最大高度为O(log2n) ;设 nh 是高度为h( h>= 0)的平衡二叉树的最小结点数,nh = nh-1 + nh-2 + 1 ,nh = Fh+2 - 1, (Fh+2,斐波那契序列),1,2,4,7,12,20,...
1 typedef struct AVLNode *Position;
2 typedef Position AVLTree; /* AVL树类型 */
3 struct AVLNode{
4 ElementType Data; /* 结点数据 */
5 AVLTree Left; /* 指向左子树 */
6 AVLTree Right; /* 指向右子树 */
7 int Height; /* 树高 */
8 };
9
10 int Max ( int a, int b )
11 {
12 return a > b ? a : b;
13 }
14
15 AVLTree GetHeight(AVLTree A){
16 if(!A) return -1;
17 return A->Height;
18 }
19
20 AVLTree SingleLeftRotation ( AVLTree A )
21 { /* 注意:A必须有一个左子结点B */
22 /* 将A与B做左单旋,更新A与B的高度,返回新的根结点B */
23
24 AVLTree B = A->Left;
25 A->Left = B->Right;
26 B->Right = A;
27 A->Height = Max( GetHeight(A->Left), GetHeight(A->Right) ) + 1;
28 B->Height = Max( GetHeight(B->Left), A->Height ) + 1;
29
30 return B;
31 }
32
33 AVLTree DoubleLeftRightRotation ( AVLTree A )
34 { /* 注意:A必须有一个左子结点B,且B必须有一个右子结点C */
35 /* 将A、B与C做两次单旋,返回新的根结点C */
36
37 /* 将B与C做右单旋,C被返回 */
38 A->Left = SingleRightRotation(A->Left);
39 /* 将A与C做左单旋,C被返回 */
40 return SingleLeftRotation(A);
41 }
42
43 AVLTree SingleRightRotation ( AVLTree A )
44 { /* 注意:A必须有一个右子结点B */
45 /* 将A与B做右单旋,更新A与B的高度,返回新的根结点B */
46
47 AVLTree B = A->Right;
48 A->Right = B->Left;
49 B->Left = A;
50 A->Height = Max( GetHeight(A->Left), GetHeight(A->Right) ) + 1;
51 B->Height = Max( GetHeight(B->Left), A->Height ) + 1;
52
53 return B;
54 }
55
56 AVLTree DoubleRightLeftRotation ( AVLTree A )
57 { /* 注意:A必须有一个右子结点B,且B必须有一个左子结点C */
58 /* 将A、B与C做两次单旋,返回新的根结点C */
59
60 /* 将B与C做右单旋,C被返回 */
61 A->Right = SingleLeftRotation(A->Right);
62 /* 将A与C做右单旋,C被返回 */
63 return SingleRightRotation(A);
64 }
65
66 AVLTree Insert( AVLTree T, ElementType X )
67 { /* 将X插入AVL树T中,并且返回调整后的AVL树 */
68 if ( !T ) { /* 若插入空树,则新建包含一个结点的树 */
69 T = (AVLTree)malloc(sizeof(struct AVLNode));
70 T->Data = X;
71 T->Height = 0;
72 T->Left = T->Right = NULL;
73 } /* if (插入空树) 结束 */
74
75 else if ( X < T->Data ) {
76 /* 插入T的左子树 */
77 T->Left = Insert( T->Left, X);
78 /* 如果需要左旋 */
79 if ( GetHeight(T->Left)-GetHeight(T->Right) == 2 )
80 if ( X < T->Left->Data )
81 T = SingleLeftRotation(T); /* 左单旋 */
82 else
83 T = DoubleLeftRightRotation(T); /* 左-右双旋 */
84 } /* else if (插入左子树) 结束 */
85
86 else if ( X > T->Data ) {
87 /* 插入T的右子树 */
88 T->Right = Insert( T->Right, X );
89 /* 如果需要右旋 */
90 if ( GetHeight(T->Left)-GetHeight(T->Right) == -2 )
91 if ( X > T->Right->Data )
92 T = SingleRightRotation(T); /* 右单旋 */
93 else
94 T = DoubleRightLeftRotation(T); /* 右-左双旋 */
95 } /* else if (插入右子树) 结束 */
96
97 /* else X == T->Data,无须插入 */
98
99 /* 别忘了更新树高 */
100 T->Height = Max( GetHeight(T->Left), GetHeight(T->Right) ) + 1;
101
102 return T;
103 }
1 #include <stdio.h>
2 #include <malloc.h>
3
4 typedef int ElementType;
5 typedef struct AVLNode *Position;
6 typedef Position AVLTree; /* AVL树类型 */
7 struct AVLNode{
8 ElementType Data; /* 结点数据 */
9 AVLTree Left; /* 指向左子树 */
10 AVLTree Right; /* 指向右子树 */
11 int Height; /* 树高 */
12 };
13
14 /* AVL树左右单旋\左右双旋\右左双旋\插入 */
15 int GetHeight( AVLTree A ); /* 树高 */
16 int Max ( int a, int b ); /* 结点数据大小 */
17 AVLTree SingleLeftRotation ( AVLTree A );
18 AVLTree SingleRightRotation ( AVLTree A );
19 AVLTree DoubleLeftRightRotation ( AVLTree A );
20 AVLTree DoubleRightLeftRotation ( AVLTree A );
21 AVLTree Insert( AVLTree T, ElementType X );
22
23 /* 主程序 */
24 int main()
25 {
26 AVLTree AVLT = NULL;
27 int N, i;
28 ElementType X;
29 scanf("%d", &N);
30 for ( i=0; i<N; i++ ) {
31 scanf("%d", &X);
32 AVLT = Insert(AVLT, X);
33 }
34 printf("%d\n", AVLT->Data);
35 return 0;
36 }
37
38 /* 树高 */
39 int GetHeight(AVLTree A)
40 {
41 if(!A) return -1;
42 return A->Height;
43 }
44
45 /* 树数据大小 */
46 int Max ( int a, int b )
47 {
48 return a > b ? a : b;
49 }
50
51 /* 左单旋 */
52 AVLTree SingleLeftRotation ( AVLTree A )
53 { /* 注意:A必须有一个左子结点B */
54 /* 将A与B做左单旋,更新A与B的高度,返回新的根结点B */
55
56 AVLTree B = A->Left;
57 A->Left = B->Right;
58 B->Right = A;
59 A->Height = Max( GetHeight(A->Left), GetHeight(A->Right) ) + 1;
60 B->Height = Max( GetHeight(B->Left), A->Height ) + 1;
61
62 return B;
63 }
64
65 /* 右单旋 */
66 AVLTree SingleRightRotation ( AVLTree A )
67 { /* 注意:A必须有一个右子结点B */
68 /* 将A与B做右单旋,更新A与B的高度,返回新的根结点B */
69
70 AVLTree B = A->Right;
71 A->Right = B->Left;
72 B->Left = A;
73 A->Height = Max( GetHeight(A->Left), GetHeight(A->Right) ) + 1;
74 B->Height = Max( GetHeight(B->Left), A->Height ) + 1;
75
76 return B;
77 }
78
79 /* 左右双旋 */
80 AVLTree DoubleLeftRightRotation ( AVLTree A )
81 { /* 注意:A必须有一个左子结点B,且B必须有一个右子结点C */
82 /* 将A、B与C做两次单旋,返回新的根结点C */
83
84 /* 将B与C做右单旋,C被返回 */
85 A->Left = SingleRightRotation(A->Left);
86 /* 将A与C做左单旋,C被返回 */
87 return SingleLeftRotation(A);
88 }
89
90 /* 右左双旋 */
91 AVLTree DoubleRightLeftRotation ( AVLTree A )
92 { /* 注意:A必须有一个右子结点B,且B必须有一个左子结点C */
93 /* 将A、B与C做两次单旋,返回新的根结点C */
94
95 /* 将B与C做右单旋,C被返回 */
96 A->Right = SingleLeftRotation(A->Right);
97 /* 将A与C做右单旋,C被返回 */
98 return SingleRightRotation(A);
99 }
100
101 /* 插入 */
102 AVLTree Insert( AVLTree T, ElementType X )
103 { /* 将X插入AVL树T中,并且返回调整后的AVL树 */
104 if ( !T ) { /* 若插入空树,则新建包含一个结点的树 */
105 T = (AVLTree)malloc(sizeof(struct AVLNode));
106 T->Data = X;
107 T->Height = 0;
108 T->Left = T->Right = NULL;
109 } /* if (插入空树) 结束 */
110
111 else if ( X < T->Data ) {
112 /* 插入T的左子树 */
113 T->Left = Insert( T->Left, X);
114 /* 如果需要左旋 */
115 if ( GetHeight(T->Left)-GetHeight(T->Right) == 2 )
116 if ( X < T->Left->Data )
117 T = SingleLeftRotation(T); /* 左单旋 */
118 else
119 T = DoubleLeftRightRotation(T); /* 左-右双旋 */
120 } /* else if (插入左子树) 结束 */
121
122 else if ( X > T->Data ) {
123 /* 插入T的右子树 */
124 T->Right = Insert( T->Right, X );
125 /* 如果需要右旋 */
126 if ( GetHeight(T->Left)-GetHeight(T->Right) == -2 )
127 if ( X > T->Right->Data )
128 T = SingleRightRotation(T); /* 右单旋 */
129 else
130 T = DoubleRightLeftRotation(T); /* 右-左双旋 */
131 } /* else if (插入右子树) 结束 */
132
133 /* else X == T->Data,无须插入 */
134
135 /* 别忘了更新树高 */
136 T->Height = Max( GetHeight(T->Left), GetHeight(T->Right) ) + 1;
137
138 return T;
139 }
五、判断完全二叉树( 循环队列 \ 层序遍历 \ 树结构 \ 队列结构 )
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <stdbool.h>
4
5 /* 树结点 */
6 typedef struct TreeNode *BinTree;
7 typedef struct TreeNode TreeNode;
8 struct TreeNode{
9 int Data, ID;
10 BinTree Left;
11 BinTree Right;
12 };
13
14 /* 顺序循环队列*/
15 #define MAXSIZE 21 //最大队列长度 N
16 typedef struct QNode *Queue;
17 struct QNode {
18 BinTree* Data; /* 存储元素的数组 */
19 int Front, Rear; /* 队列的头、尾指针 */
20 int MaxSize; /* 队列最大容量 */
21 };
22
23 BinTree Insert( BinTree BST, int X ); /* 插入 */
24 void LevelorderTraversal ( BinTree BT ); /* 层次遍历 */
25 Queue CreateQueue( ); /* 建队 */
26 bool IsFull( Queue Q ); /* 队满 */
27 bool IsEmpty( Queue Q ); /* 队空 */
28 bool AddQ( Queue Q, BinTree X ); /* 入队 */
29 BinTree DeleteQ( Queue Q ); /* 出队 */
30
31 int main()
32 {
33 int N, i, X;
34 scanf("%d", &N);
35
36 BinTree BST = NULL;
37 for ( i=0; i<N; i++ ) {
38 scanf("%d", &X);
39 BST = Insert(BST, X);
40 }
41 LevelorderTraversal(BST);
42 return 0;
43 }
44
45 BinTree Insert( BinTree BST, int X )
46 {
47 if(!BST)
48 {
49 BST = (BinTree)malloc(sizeof(TreeNode));
50 BST->Data = X;
51 BST->Left = NULL;
52 BST->Right = NULL;
53 }
54 else
55 {
56 if(X > BST->Data)
57 BST->Left = Insert(BST->Left,X);
58 else if(BST->Data > X)
59 BST->Right = Insert(BST->Right,X);
60 }
61 return BST;
62 }
63
64 void LevelorderTraversal ( BinTree BT )
65 {
66 Queue Q;
67 BinTree T;
68
69 bool flag = true, ans = true;
70 int order = 0; /* 顺序 */
71
72 if ( !BT ) return; /* 若是空树则直接返回 */
73
74 Q = CreateQueue(); /* 创建空队列Q */
75
76
77 AddQ( Q, BT ); /* 树根入队 */
78 BT->ID = 1;
79
80 while ( !IsEmpty(Q) )
81 {
82 T = DeleteQ( Q ); /* 出队 */
83 order++;
84
85 if(T->ID != order)
86 ans = false; /* 顺序不同 */
87 if(flag) /* 输出格式 */
88 {
89 printf("%d", T->Data);
90 flag = false;
91 }
92 else printf(" %d", T->Data);
93
94 if ( T->Left ){
95 T->Left->ID = 2 * T->ID; /* 左儿子顺序 */
96 AddQ( Q, T->Left ); /* 左儿子入队 */
97 }
98 if ( T->Right ){
99 T->Right->ID = 2 * T->ID + 1;/* 右儿子顺序 */
100 AddQ( Q, T->Right ); /* 右儿子入队 */
101 }
102 }
103
104 if(ans) /* 顺序相同 */
105 printf("\nYES");
106 else
107 printf("\nNO");
108 }
109
110 /* 建队列 */
111 Queue CreateQueue( )//返回队列指针
112 {
113 Queue Q = (Queue)malloc(sizeof(struct QNode));
114 Q->Data = (BinTree*)malloc(MAXSIZE * sizeof(BinTree));
115 Q->Front = Q->Rear = 0;
116 Q->MaxSize = MAXSIZE;
117 return Q;
118 }
119
120 /* 队满 */
121 bool IsFull( Queue Q )
122 {
123 return ((Q->Rear+1)%Q->MaxSize == Q->Front);
124 }
125
126 /* 队空 */
127 bool IsEmpty( Queue Q )
128 {
129 return (Q->Front == Q->Rear);
130 }
131
132 /* 入队 */
133 bool AddQ( Queue Q, BinTree X )
134 {
135 if ( IsFull(Q) ) {
136 return false;
137 }
138 else {
139 Q->Rear = (Q->Rear+1)%Q->MaxSize;
140 Q->Data[Q->Rear] = X;
141 return true;
142 }
143 }
144
145 /* 出队 */
146 BinTree DeleteQ( Queue Q )
147 {
148 if ( IsEmpty(Q) )
149 return NULL;
150 Q->Front =(Q->Front+1)%Q->MaxSize;
151 return Q->Data[Q->Front];
152 }