数据结构之二叉树

        既然树已经熟悉了，那我们就来学习学习二叉树吧，二叉树是由n(n>=0)个结点组成的有限集合，该集合或者为空，或者是由一个根结点加上两棵分别称为左子树和右子树的﹑互不相交的二叉树组成。

        如图

        

有两个定义需要大家知道下：

1.满二叉树

        如果二叉树中所有分支结点的度数都为2，且叶子结点都在同一层次上，则称这类二叉树为满二叉树。

2.完全二叉树

        如果一棵具有n个结点的高度为k的二叉树，它的每一个结点都与高度为k的满二叉树中编号为1-n的结点一一对应，则称这棵二叉树为完全二叉树。（从上到下从左到右编号）

        完全二叉树的叶结点仅出现在最下面两层

        最下层的叶结点一定出现在左边

        倒数第二层的叶结点一定出现在右边

        完全二叉树中度为1的结点只有左孩子

        同样结点数的二叉树，完全二叉树的高度最小

二叉树所具有的5个性质需要大家掌握：

 

这里介绍通用树的常用操作：

l 创建二叉树

l 销毁二叉树

l 清空二叉树

l 插入结点到二叉树中

l 删除结点

l 获取某个结点

l 获取根结点

l 获取二叉树的高度

l 获取二叉树的总结点数

l 获取二叉树的度

l 输出二叉树

代码总分为三个文件：

BTree.h ： 放置功能函数的声明，以及树的声明，以及树结点的定义 

BTree.c ： 放置功能函数的定义，以及树的定义

Main.c   ： 主函数，使用功能函数完成各种需求，一般用作测试

整体结构图为：

这里详细说下插入结点操作，删除结点操作和获取结点操作：

 

插入结点操作：

如图：

  

删除结点操作：

如图：

获取结点操作：

            获取结点操作和插入删除结点操作中的指路法定位结点相同

OK! 上代码：

BTree.h ： 

[cpp] view plain copy

1. #ifndef _BTREE_H_  
2. #define _BTREE_H_  
3.   
4. #define BT_LEFT 0  
5. #define BT_RIGHT 1  
6.   
7. typedef void BTree;  
8. typedef unsigned long long BTPos;  
9.   
10. typedef struct _tag_BTreeNode BTreeNode;  
11. struct _tag_BTreeNode  
12. {  
13.     BTreeNode* left;  
14.     BTreeNode* right;  
15. };  
16.   
17. typedef void (BTree_Printf)(BTreeNode*);  
18.   
19. BTree* BTree_Create();  
20.   
21. void BTree_Destroy(BTree* tree);  
22.   
23. void BTree_Clear(BTree* tree);  
24.   
25. int BTree_Insert(BTree* tree, BTreeNode* node, BTPos pos, int count, int flag);  
26.   
27. BTreeNode* BTree_Delete(BTree* tree, BTPos pos, int count);  
28.   
29. BTreeNode* BTree_Get(BTree* tree, BTPos pos, int count);  
30.   
31. BTreeNode* BTree_Root(BTree* tree);  
32.   
33. int BTree_Height(BTree* tree);  
34.   
35. int BTree_Count(BTree* tree);  
36.   
37. int BTree_Degree(BTree* tree);  
38.   
39. void BTree_Display(BTree* tree, BTree_Printf* pFunc, int gap, char div);  
40.   
41. #endif  

 

BTree.c ： 

[cpp] view plain copy

1. #include <stdio.h>  
2. #include <malloc.h>  
3. #include “BTree.h”  
4.   
5. typedef struct _tag_BTree TBTree;  
6. struct _tag_BTree  
7. {  
8.     int count;  
9.     BTreeNode* root;  
10. };  
11.   
12. BTree* BTree_Create()  
13. {  
14.     TBTree* ret = (TBTree*)malloc(sizeof(TBTree));  
15.       
16.     if(NULL != ret)  
17.     {  
18.         ret->count = 0;  
19.         ret->root  = NULL;  
20.     }  
21.       
22.     return ret;  
23. }  
24.   
25. void BTree_Destroy(BTree* tree)  
26. {  
27.     free(tree);  
28. }  
29.   
30. void BTree_Clear(BTree* tree)  
31. {  
32.     TBTree* btree = (TBTree*)tree;  
33.       
34.     if(NULL != btree)  
35.     {  
36.         btree->count = 0;  
37.         btree->root = NULL;  
38.     }  
39. }  
40.   
41. int BTree_Insert(BTree* tree, BTreeNode* node, BTPos pos, int count, int flag)  
42. {  
43.     TBTree* btree = (TBTree*)tree;  
44.       
45.     int ret = (NULL!=btree) && (NULL!=node) && ((flag == BT_RIGHT) || (flag == BT_LEFT));  
46.       
47.     int bit = 0;  
48.       
49.     if(ret)  
50.     {  
51.         BTreeNode* parent = NULL;  
52.         BTreeNode* current = btree->root;  
53.           
54.         node->left = NULL;  
55.         node->right = NULL;  
56.           
57.         while((0 < count) && (NULL != current))  
58.         {  
59.             bit = pos & 1;  
60.             pos = pos >> 1;  
61.       
62.             parent = current;  
63.               
64.             if(BT_LEFT == bit)  
65.             {  
66.                 current = current->left;  
67.             }  
68.             else if(BT_RIGHT == bit)  
69.             {  
70.                 current = current->right;  
71.             }  
72.               
73.             count–;  
74.         }  
75.           
76.         if(BT_LEFT == flag)  
77.         {  
78.             node->left = current;  
79.         }  
80.         else if(BT_RIGHT == flag)  
81.         {  
82.             node->right = current;  
83.         }  
84.           
85.         if(NULL != parent)  
86.         {  
87.             if(BT_LEFT == bit)  
88.             {  
89.                 parent->left = node;   
90.             }  
91.             else if(BT_RIGHT == bit)  
92.             {  
93.                 parent->right = node;  
94.             }  
95.         }  
96.         else  
97.         {  
98.             btree->root = node;  
99.         }  
100.           
101.         btree->count++;  
102.     }  
103.   
104.     return ret;  
105. }  
106.   
107. static int recursive_count(BTreeNode* root)  
108. {  
109.     int ret = 0;  
110.       
111.     if(NULL != root)  
112.     {  
113.         ret = recursive_count(root->left) + 1 +   
114.               recursive_count(root->right);  
115.     }  
116.       
117.     return ret;  
118. }  
119.   
120. BTreeNode* BTree_Delete(BTree* tree, BTPos pos, int count)  
121. {  
122.     TBTree* btree = (TBTree*)tree;  
123.       
124.     BTreeNode* ret = NULL;  
125.       
126.     int bit = 0;  
127.       
128.     if(NULL != btree)  
129.     {  
130.         BTreeNode* parent = NULL;  
131.         BTreeNode* current = btree->root;  
132.           
133.         while((0 < count) && (NULL != current))  
134.         {  
135.             bit = pos & 1;  
136.             pos = pos >> 1;  
137.               
138.             parent = current;  
139.               
140.             if(BT_RIGHT == bit)  
141.             {  
142.                 current = current->right;  
143.             }  
144.             else if(BT_LEFT == bit)  
145.             {  
146.                 current = current->left;  
147.             }  
148.               
149.             count–;  
150.         }  
151.           
152.         if(NULL != parent)  
153.         {  
154.             if(BT_LEFT == bit)  
155.             {  
156.                 parent->left = NULL;  
157.             }  
158.             else if (BT_RIGHT == bit)  
159.             {  
160.                 parent->right = NULL;  
161.             }  
162.         }  
163.         else  
164.         {  
165.             btree->root = NULL;  
166.         }  
167.           
168.         ret = current;  
169.         btree->count = btree->count - recursive_count(ret);  
170.     }  
171.       
172.     return ret;  
173. }  
174.   
175.   
176. BTreeNode* BTree_Get(BTree* tree, BTPos pos, int count)  
177. {  
178.     TBTree* btree = (TBTree*)tree;  
179.       
180.     BTreeNode* ret = NULL;  
181.       
182.     int bit = 0;  
183.       
184.     if(NULL != btree)  
185.     {  
186.         BTreeNode* current = btree->root;  
187.           
188.         while((0<count) && (NULL!=current))  
189.         {  
190.             bit = pos & 1;  
191.             pos = pos >> 1;  
192.               
193.             if(BT_RIGHT == bit)  
194.             {  
195.                 current = current->right;  
196.             }  
197.             else if(BT_LEFT == bit)  
198.             {  
199.                 current = current->left;  
200.             }  
201.               
202.             count–;  
203.         }  
204.           
205.         ret = current;  
206.     }  
207.       
208.     return ret;  
209. }  
210.   
211. BTreeNode* BTree_Root(BTree* tree)  
212. {  
213.     TBTree* btree = (TBTree*)tree;  
214.       
215.     BTreeNode* ret = NULL;  
216.       
217.     if(NULL != btree)  
218.     {  
219.         ret = btree->root;  
220.     }  
221.       
222.     return ret;  
223. }  
224.   
225. static int recursive_height(BTreeNode* root)  
226. {  
227.     int ret = 0;  
228.       
229.     if(NULL != root)  
230.     {  
231.         int lh = recursive_height(root->left);  
232.         int rh = recursive_height(root->right);  
233.           
234.         ret = ((lh > rh) ? lh : rh) + 1;  
235.     }     
236.       
237.     return ret;  
238. }  
239.   
240. int BTree_Height(BTree* tree)  
241. {  
242.     TBTree* btree = (TBTree*)tree;  
243.       
244.     int ret = -1;  
245.       
246.     if(NULL != btree)  
247.     {  
248.         ret = recursive_height(btree->root);  
249.     }  
250.       
251.     return ret;  
252. }  
253.   
254. int BTree_Count(BTree* tree)  
255. {  
256.     TBTree* btree = (TBTree*)tree;  
257.       
258.     int ret = -1;  
259.       
260.     if(NULL != btree)  
261.     {  
262.         ret = btree->count;  
263.     }  
264.       
265.     return ret;  
266. }  
267.   
268. static int recursive_degree(BTreeNode* root)  
269. {  
270.     int ret = 0;  
271.       
272.     if(NULL != root)  
273.     {  
274.         if(NULL != root->left)  
275.         {  
276.             ret++;  
277.         }  
278.         if(NULL != root->right)  
279.         {  
280.             ret++;  
281.         }  
282.           
283.         if(1 == ret)  
284.         {  
285.             int ld = recursive_degree(root->left);  
286.             int rd = recursive_degree(root->right);  
287.               
288.             if(ret < ld)  
289.             {  
290.                 ret = ld;  
291.             }  
292.             if(ret < rd)  
293.             {  
294.                 ret = rd;  
295.             }  
296.         }  
297.     }  
298.       
299.     return ret;  
300. }  
301.   
302. int BTree_Degree(BTree* tree)  
303. {  
304.     TBTree* btree = (TBTree*)tree;  
305.       
306.     int ret = -1;  
307.       
308.     if(NULL != btree)  
309.     {  
310.         ret = recursive_degree(btree->root);  
311.     }  
312.       
313.     return ret;  
314. }  
315.   
316. static void recursive_display(BTreeNode* node, BTree_Printf* pFunc, int format, int gap, char div)  
317. {  
318.     int i = 0;  
319.       
320.     if((NULL != node) && (NULL != pFunc))  
321.     {  
322.         for(i=0; i<format; i++)  
323.         {  
324.             printf(”%c”, div);  
325.         }  
326.         pFunc(node);  
327.         printf(”\n”);  
328.           
329.         if((NULL != node->left) || (NULL != node->right))  
330.         {  
331.             recursive_display(node->left, pFunc, format+gap, gap, div);  
332.             recursive_display(node->right, pFunc, format+gap, gap, div);  
333.         }  
334.     }  
335.     else  
336.     {  
337.         for(i=0; i<format; i++)  
338.         {  
339.             printf(”%c”, div);  
340.         }  
341.         printf(”\n”);  
342.     }  
343. }  
344.   
345. void BTree_Display(BTree* tree, BTree_Printf* pFunc, int gap, char div)  
346. {  
347.     TBTree* btree = (TBTree*)tree;  
348.       
349.     if(NULL != btree)  
350.     {  
351.         recursive_display(btree->root, pFunc, 0, gap, div);  
352.     }  
353. }  

 

Main.c  ：

[cpp] view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include “BTree.h”  
4.   
5. typedef struct _tag_node  
6. {  
7.     BTreeNode header;  
8.     char v;  
9. }Node;  
10.   
11. void printf_data(BTreeNode* node)  
12. {  
13.     if(NULL != node)  
14.     {  
15.         printf(”%c”, ((Node*)node)->v);  
16.     }  
17. }  
18.   
19. int main(void)  
20. {  
21.     BTree* tree = BTree_Create();  
22.       
23.     Node n1 = {{NULL, NULL}, ’A’};  
24.     Node n2 = {{NULL, NULL}, ’B’};  
25.     Node n3 = {{NULL, NULL}, ’C’};  
26.     Node n4 = {{NULL, NULL}, ’D’};  
27.     Node n5 = {{NULL, NULL}, ’E’};  
28.     Node n6 = {{NULL, NULL}, ’F’};  
29.       
30.     BTree_Insert(tree, (BTreeNode*)&n1,    0, 0, 0);  
31.     BTree_Insert(tree, (BTreeNode*)&n2, 0x00, 1, 0);  
32.     BTree_Insert(tree, (BTreeNode*)&n3, 0x01, 1, 0);  
33.     BTree_Insert(tree, (BTreeNode*)&n4, 0x00, 2, 0);  
34.     BTree_Insert(tree, (BTreeNode*)&n5, 0x02, 2, 0);  
35.     BTree_Insert(tree, (BTreeNode*)&n6, 0x02, 3, 0);  
36.       
37.     printf(”Height:  %d\n”, BTree_Height(tree));  
38.     printf(”Degree:  %d\n”, BTree_Degree(tree));  
39.     printf(”Count :  %d\n”, BTree_Count(tree));  
40.     printf(”Position At (0x02, 2): %c \n”, ((Node*)BTree_Get(tree, 0x02, 2))->v);  
41.       
42.     printf(”Full Tree:\n”);  
43.     BTree_Display(tree, printf_data, 4, ’-‘);  
44.       
45.     BTree_Delete(tree, 0x00, 1);  
46.     printf(”After Delete B: \n”);  
47.     printf(”Height:  %d\n”, BTree_Height(tree));  
48.     printf(”Degree:  %d\n”, BTree_Degree(tree));  
49.     printf(”Count :  %d\n”, BTree_Count(tree));  
50.       
51.     printf(”Full Tree:\n”);  
52.     BTree_Display(tree, printf_data, 4, ’-‘);  
53.       
54.     BTree_Clear(tree);  
55.     printf(”After Clear:\n”);  
56.     printf(”Height:  %d\n”, BTree_Height(tree));  
57.     printf(”Degree:  %d\n”, BTree_Degree(tree));  
58.     printf(”Count :  %d\n”, BTree_Count(tree));  
59.       
60.     printf(”Full Tree:\n”);  
61.     BTree_Display(tree, printf_data, 4, ’-‘);  
62.       
63.     BTree_Destroy(tree);  
64.       
65.     return 0;  
66. }  

        既然树已经熟悉了，那我们就来学习学习二叉树吧，二叉树是由n(n>=0)个结点组成的有限集合，该集合或者为空，或者是由一个根结点加上两棵分别称为左子树和右子树的﹑互不相交的二叉树组成。

        如图

        

有两个定义需要大家知道下：

1.满二叉树

        如果二叉树中所有分支结点的度数都为2，且叶子结点都在同一层次上，则称这类二叉树为满二叉树。

2.完全二叉树

        如果一棵具有n个结点的高度为k的二叉树，它的每一个结点都与高度为k的满二叉树中编号为1-n的结点一一对应，则称这棵二叉树为完全二叉树。（从上到下从左到右编号）

        完全二叉树的叶结点仅出现在最下面两层

        最下层的叶结点一定出现在左边

        倒数第二层的叶结点一定出现在右边

        完全二叉树中度为1的结点只有左孩子

        同样结点数的二叉树，完全二叉树的高度最小

二叉树所具有的5个性质需要大家掌握：

 

这里介绍通用树的常用操作：

l 创建二叉树

l 销毁二叉树

l 清空二叉树

l 插入结点到二叉树中

l 删除结点

l 获取某个结点

l 获取根结点

l 获取二叉树的高度

l 获取二叉树的总结点数

l 获取二叉树的度

l 输出二叉树

代码总分为三个文件：

BTree.h ： 放置功能函数的声明，以及树的声明，以及树结点的定义 

BTree.c ： 放置功能函数的定义，以及树的定义

Main.c   ： 主函数，使用功能函数完成各种需求，一般用作测试

整体结构图为：

这里详细说下插入结点操作，删除结点操作和获取结点操作：

 

插入结点操作：

如图：

  

删除结点操作：

如图：

获取结点操作：

            获取结点操作和插入删除结点操作中的指路法定位结点相同

OK! 上代码：

BTree.h ： 

[cpp] view plain copy

1. #ifndef _BTREE_H_  
2. #define _BTREE_H_  
3.   
4. #define BT_LEFT 0  
5. #define BT_RIGHT 1  
6.   
7. typedef void BTree;  
8. typedef unsigned long long BTPos;  
9.   
10. typedef struct _tag_BTreeNode BTreeNode;  
11. struct _tag_BTreeNode  
12. {  
13.     BTreeNode* left;  
14.     BTreeNode* right;  
15. };  
16.   
17. typedef void (BTree_Printf)(BTreeNode*);  
18.   
19. BTree* BTree_Create();  
20.   
21. void BTree_Destroy(BTree* tree);  
22.   
23. void BTree_Clear(BTree* tree);  
24.   
25. int BTree_Insert(BTree* tree, BTreeNode* node, BTPos pos, int count, int flag);  
26.   
27. BTreeNode* BTree_Delete(BTree* tree, BTPos pos, int count);  
28.   
29. BTreeNode* BTree_Get(BTree* tree, BTPos pos, int count);  
30.   
31. BTreeNode* BTree_Root(BTree* tree);  
32.   
33. int BTree_Height(BTree* tree);  
34.   
35. int BTree_Count(BTree* tree);  
36.   
37. int BTree_Degree(BTree* tree);  
38.   
39. void BTree_Display(BTree* tree, BTree_Printf* pFunc, int gap, char div);  
40.   
41. #endif  

 

BTree.c ： 

[cpp] view plain copy

1. #include <stdio.h>  
2. #include <malloc.h>  
3. #include “BTree.h”  
4.   
5. typedef struct _tag_BTree TBTree;  
6. struct _tag_BTree  
7. {  
8.     int count;  
9.     BTreeNode* root;  
10. };  
11.   
12. BTree* BTree_Create()  
13. {  
14.     TBTree* ret = (TBTree*)malloc(sizeof(TBTree));  
15.       
16.     if(NULL != ret)  
17.     {  
18.         ret->count = 0;  
19.         ret->root  = NULL;  
20.     }  
21.       
22.     return ret;  
23. }  
24.   
25. void BTree_Destroy(BTree* tree)  
26. {  
27.     free(tree);  
28. }  
29.   
30. void BTree_Clear(BTree* tree)  
31. {  
32.     TBTree* btree = (TBTree*)tree;  
33.       
34.     if(NULL != btree)  
35.     {  
36.         btree->count = 0;  
37.         btree->root = NULL;  
38.     }  
39. }  
40.   
41. int BTree_Insert(BTree* tree, BTreeNode* node, BTPos pos, int count, int flag)  
42. {  
43.     TBTree* btree = (TBTree*)tree;  
44.       
45.     int ret = (NULL!=btree) && (NULL!=node) && ((flag == BT_RIGHT) || (flag == BT_LEFT));  
46.       
47.     int bit = 0;  
48.       
49.     if(ret)  
50.     {  
51.         BTreeNode* parent = NULL;  
52.         BTreeNode* current = btree->root;  
53.           
54.         node->left = NULL;  
55.         node->right = NULL;  
56.           
57.         while((0 < count) && (NULL != current))  
58.         {  
59.             bit = pos & 1;  
60.             pos = pos >> 1;  
61.       
62.             parent = current;  
63.               
64.             if(BT_LEFT == bit)  
65.             {  
66.                 current = current->left;  
67.             }  
68.             else if(BT_RIGHT == bit)  
69.             {  
70.                 current = current->right;  
71.             }  
72.               
73.             count–;  
74.         }  
75.           
76.         if(BT_LEFT == flag)  
77.         {  
78.             node->left = current;  
79.         }  
80.         else if(BT_RIGHT == flag)  
81.         {  
82.             node->right = current;  
83.         }  
84.           
85.         if(NULL != parent)  
86.         {  
87.             if(BT_LEFT == bit)  
88.             {  
89.                 parent->left = node;   
90.             }  
91.             else if(BT_RIGHT == bit)  
92.             {  
93.                 parent->right = node;  
94.             }  
95.         }  
96.         else  
97.         {  
98.             btree->root = node;  
99.         }  
100.           
101.         btree->count++;  
102.     }  
103.   
104.     return ret;  
105. }  
106.   
107. static int recursive_count(BTreeNode* root)  
108. {  
109.     int ret = 0;  
110.       
111.     if(NULL != root)  
112.     {  
113.         ret = recursive_count(root->left) + 1 +   
114.               recursive_count(root->right);  
115.     }  
116.       
117.     return ret;  
118. }  
119.   
120. BTreeNode* BTree_Delete(BTree* tree, BTPos pos, int count)  
121. {  
122.     TBTree* btree = (TBTree*)tree;  
123.       
124.     BTreeNode* ret = NULL;  
125.       
126.     int bit = 0;  
127.       
128.     if(NULL != btree)  
129.     {  
130.         BTreeNode* parent = NULL;  
131.         BTreeNode* current = btree->root;  
132.           
133.         while((0 < count) && (NULL != current))  
134.         {  
135.             bit = pos & 1;  
136.             pos = pos >> 1;  
137.               
138.             parent = current;  
139.               
140.             if(BT_RIGHT == bit)  
141.             {  
142.                 current = current->right;  
143.             }  
144.             else if(BT_LEFT == bit)  
145.             {  
146.                 current = current->left;  
147.             }  
148.               
149.             count–;  
150.         }  
151.           
152.         if(NULL != parent)  
153.         {  
154.             if(BT_LEFT == bit)  
155.             {  
156.                 parent->left = NULL;  
157.             }  
158.             else if (BT_RIGHT == bit)  
159.             {  
160.                 parent->right = NULL;  
161.             }  
162.         }  
163.         else  
164.         {  
165.             btree->root = NULL;  
166.         }  
167.           
168.         ret = current;  
169.         btree->count = btree->count - recursive_count(ret);  
170.     }  
171.       
172.     return ret;  
173. }  
174.   
175.   
176. BTreeNode* BTree_Get(BTree* tree, BTPos pos, int count)  
177. {  
178.     TBTree* btree = (TBTree*)tree;  
179.       
180.     BTreeNode* ret = NULL;  
181.       
182.     int bit = 0;  
183.       
184.     if(NULL != btree)  
185.     {  
186.         BTreeNode* current = btree->root;  
187.           
188.         while((0<count) && (NULL!=current))  
189.         {  
190.             bit = pos & 1;  
191.             pos = pos >> 1;  
192.               
193.             if(BT_RIGHT == bit)  
194.             {  
195.                 current = current->right;  
196.             }  
197.             else if(BT_LEFT == bit)  
198.             {  
199.                 current = current->left;  
200.             }  
201.               
202.             count–;  
203.         }  
204.           
205.         ret = current;  
206.     }  
207.       
208.     return ret;  
209. }  
210.   
211. BTreeNode* BTree_Root(BTree* tree)  
212. {  
213.     TBTree* btree = (TBTree*)tree;  
214.       
215.     BTreeNode* ret = NULL;  
216.       
217.     if(NULL != btree)  
218.     {  
219.         ret = btree->root;  
220.     }  
221.       
222.     return ret;  
223. }  
224.   
225. static int recursive_height(BTreeNode* root)  
226. {  
227.     int ret = 0;  
228.       
229.     if(NULL != root)  
230.     {  
231.         int lh = recursive_height(root->left);  
232.         int rh = recursive_height(root->right);  
233.           
234.         ret = ((lh > rh) ? lh : rh) + 1;  
235.     }     
236.       
237.     return ret;  
238. }  
239.   
240. int BTree_Height(BTree* tree)  
241. {  
242.     TBTree* btree = (TBTree*)tree;  
243.       
244.     int ret = -1;  
245.       
246.     if(NULL != btree)  
247.     {  
248.         ret = recursive_height(btree->root);  
249.     }  
250.       
251.     return ret;  
252. }  
253.   
254. int BTree_Count(BTree* tree)  
255. {  
256.     TBTree* btree = (TBTree*)tree;  
257.       
258.     int ret = -1;  
259.       
260.     if(NULL != btree)  
261.     {  
262.         ret = btree->count;  
263.     }  
264.       
265.     return ret;  
266. }  
267.   
268. static int recursive_degree(BTreeNode* root)  
269. {  
270.     int ret = 0;  
271.       
272.     if(NULL != root)  
273.     {  
274.         if(NULL != root->left)  
275.         {  
276.             ret++;  
277.         }  
278.         if(NULL != root->right)  
279.         {  
280.             ret++;  
281.         }  
282.           
283.         if(1 == ret)  
284.         {  
285.             int ld = recursive_degree(root->left);  
286.             int rd = recursive_degree(root->right);  
287.               
288.             if(ret < ld)  
289.             {  
290.                 ret = ld;  
291.             }  
292.             if(ret < rd)  
293.             {  
294.                 ret = rd;  
295.             }  
296.         }  
297.     }  
298.       
299.     return ret;  
300. }  
301.   
302. int BTree_Degree(BTree* tree)  
303. {  
304.     TBTree* btree = (TBTree*)tree;  
305.       
306.     int ret = -1;  
307.       
308.     if(NULL != btree)  
309.     {  
310.         ret = recursive_degree(btree->root);  
311.     }  
312.       
313.     return ret;  
314. }  
315.   
316. static void recursive_display(BTreeNode* node, BTree_Printf* pFunc, int format, int gap, char div)  
317. {  
318.     int i = 0;  
319.       
320.     if((NULL != node) && (NULL != pFunc))  
321.     {  
322.         for(i=0; i<format; i++)  
323.         {  
324.             printf(”%c”, div);  
325.         }  
326.         pFunc(node);  
327.         printf(”\n”);  
328.           
329.         if((NULL != node->left) || (NULL != node->right))  
330.         {  
331.             recursive_display(node->left, pFunc, format+gap, gap, div);  
332.             recursive_display(node->right, pFunc, format+gap, gap, div);  
333.         }  
334.     }  
335.     else  
336.     {  
337.         for(i=0; i<format; i++)  
338.         {  
339.             printf(”%c”, div);  
340.         }  
341.         printf(”\n”);  
342.     }  
343. }  
344.   
345. void BTree_Display(BTree* tree, BTree_Printf* pFunc, int gap, char div)  
346. {  
347.     TBTree* btree = (TBTree*)tree;  
348.       
349.     if(NULL != btree)  
350.     {  
351.         recursive_display(btree->root, pFunc, 0, gap, div);  
352.     }  
353. }  

 

Main.c  ：

[cpp] view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include “BTree.h”  
4.   
5. typedef struct _tag_node  
6. {  
7.     BTreeNode header;  
8.     char v;  
9. }Node;  
10.   
11. void printf_data(BTreeNode* node)  
12. {  
13.     if(NULL != node)  
14.     {  
15.         printf(”%c”, ((Node*)node)->v);  
16.     }  
17. }  
18.   
19. int main(void)  
20. {  
21.     BTree* tree = BTree_Create();  
22.       
23.     Node n1 = {{NULL, NULL}, ’A’};  
24.     Node n2 = {{NULL, NULL}, ’B’};  
25.     Node n3 = {{NULL, NULL}, ’C’};  
26.     Node n4 = {{NULL, NULL}, ’D’};  
27.     Node n5 = {{NULL, NULL}, ’E’};  
28.     Node n6 = {{NULL, NULL}, ’F’};  
29.       
30.     BTree_Insert(tree, (BTreeNode*)&n1,    0, 0, 0);  
31.     BTree_Insert(tree, (BTreeNode*)&n2, 0x00, 1, 0);  
32.     BTree_Insert(tree, (BTreeNode*)&n3, 0x01, 1, 0);  
33.     BTree_Insert(tree, (BTreeNode*)&n4, 0x00, 2, 0);  
34.     BTree_Insert(tree, (BTreeNode*)&n5, 0x02, 2, 0);  
35.     BTree_Insert(tree, (BTreeNode*)&n6, 0x02, 3, 0);  
36.       
37.     printf(”Height:  %d\n”, BTree_Height(tree));  
38.     printf(”Degree:  %d\n”, BTree_Degree(tree));  
39.     printf(”Count :  %d\n”, BTree_Count(tree));  
40.     printf(”Position At (0x02, 2): %c \n”, ((Node*)BTree_Get(tree, 0x02, 2))->v);  
41.       
42.     printf(”Full Tree:\n”);  
43.     BTree_Display(tree, printf_data, 4, ’-‘);  
44.       
45.     BTree_Delete(tree, 0x00, 1);  
46.     printf(”After Delete B: \n”);  
47.     printf(”Height:  %d\n”, BTree_Height(tree));  
48.     printf(”Degree:  %d\n”, BTree_Degree(tree));  
49.     printf(”Count :  %d\n”, BTree_Count(tree));  
50.       
51.     printf(”Full Tree:\n”);  
52.     BTree_Display(tree, printf_data, 4, ’-‘);  
53.       
54.     BTree_Clear(tree);  
55.     printf(”After Clear:\n”);  
56.     printf(”Height:  %d\n”, BTree_Height(tree));  
57.     printf(”Degree:  %d\n”, BTree_Degree(tree));  
58.     printf(”Count :  %d\n”, BTree_Count(tree));  
59.       
60.     printf(”Full Tree:\n”);  
61.     BTree_Display(tree, printf_data, 4, ’-‘);  
62.       
63.     BTree_Destroy(tree);  
64.       
65.     return 0;  
66. }