数据结构学习之二叉树(实践篇)

文章转自：http://blog.csdn.net/ab198604/article/details/8510906

上一篇博文主要对树、二叉树的概念及其一些基本特性进行简要的描述，偏向于理论知识。而本文的主要内容是针对二叉树这种数据结构的实现细节进行设计与分析，理论与实践相结合可以加深对系统知识的掌握。二叉树这种数据结构，应用非常广泛，在linux内核中随处可见，因此，如果能够熟练的掌握这项技能，将有助于理解其它系统。

        一、“初识”二叉树

        在代码的实现中，二叉树究竟是什么？请看下面代码：

[cpp] view plaincopy

1. /*  
2.  * filename: bitree.h 
3.  * author: zhm 
4.  * date: 2012-01-08 
5.  */  
6.   
7. #ifndef BITREE_H  
8. #define BITREE_H  
9.   
10. #include <stdlib.h>  
11.   
12. /* define a binary tree node */  
13. typedef struct BiTreeNode_  
14. {  
15.     void *data;  
16.     struct BiTreeNode_ *left;    //point to left node.  
17.     struct BiTreeNode_ *right;   //point to right node.  
18. }BiTreeNode;  

        这是一段关于二叉树结点的数据结构，一共有3个域，数据域和左右指针域，数据域包含了二叉树每个结点的关键信息，左右指针域分别指向它的左右孩子结点。

[html] view plaincopy

1. /* define a binary tree */  
2. typedef struct BiTree_  
3. {  
4.     int size;           //number of the elements in the tree.  
5.     BiTreeNode *root;   //root node.  
6.     int (*compare)(const void *key1, const void *key2);  
7.     void (*destroy)(void *data);  
8. }BiTree;  

        这里定义了一个结构体，这个结构体就是一棵二叉树了。因为它维护了一棵二叉树的重要信息，如，二叉树中结点总数size，根结点的位置root，结点数据信息的比较操作，销毁二叉树的destroy函数等。可以通过这个结构体的root域就可以方便的按深度及广度遍历整个二叉树，寻找到任何一个结点了。

        二、“深入”二叉树

        二叉树究竟是如何建立的？凡事产生均有一个过程，二叉树的建立也有一个过程。它是由不同的结点组成，按照实际情况逐一将这些结点插入从而形成二叉树，当然，也面临着结点的删除操作等，总而言之，它有以下基本操作(接口):

[cpp] view plaincopy

1. /* public interface */  
2. void bitree_init( BiTree *tree, void (*destroy)(void *data) );  
3. void bitree_destroy(BiTree *tree);  
4. int bitree_ins_left(BiTree *tree, BiTreeNode *node, const void *data);  
5. int bitree_ins_right(BiTree *tree, BiTreeNode *node, const void *data);  
6. void bitree_rem_left(BiTree *tree, BiTreeNode *node);  
7. void bitree_rem_right(BiTree *tree, BiTreeNode *node);  
8. int bitree_merge(BiTree *merge, BiTree *left, BiTree *right, const void *data);  
9.   
10. #define bitree_size(tree) ((tree)->size) //获取大小  
11. #define bitree_root(tree) ((tree)->root) //获取根结点  
12. #define bitree_is_eob(node) ((node) == NULL) //判断分支是否结束  
13. #define bitree_is_leaf(node) ((node)->left == NULL && (node)->right == NULL)  //判断是否是叶子结点  
14. #define bitree_data(node) ((node)->data) //获取数据域  
15. #define bitree_left(node) ((node)->left) //获取左结点(左孩子)  
16. #define bitree_right(node) ((node)->right)//获取右结点(右孩子)  
17.   
18. #endif  

        1 二叉树的初始化(bitree_init)：此操作完成后，一棵空的二叉树就建立了，此时它没有任何结点，这是二叉树进行后续操作的前提。

        2 二叉树的销毁(bitree_destroy)：此操作用于销毁一棵二叉树

        3 二叉树插入操作(bitree_ins_left)：将data中的信息插入到当前node结点的左指针域，成为当前node结点的左孩子。当node为NULL时，从根结点位置插入。

        4二叉树插入操作(bitree_ins_right)：同3，不同的是其插入的是右指针域。

        5 二叉树删除操作(bitree_rem_left)：删除以node结点为根的子树的左子树。当node = NULL时，则为删除整棵二叉树

        6二叉树删除操作(bitree_rem_right)：同5，不同的是其删除的是右子树。

        7 二叉树的合并(bitree_merge):将两棵二叉树，分别合并成以data域为根的新二叉树，原来这两棵二叉树分别成为新二叉树的左右子树。

        8其它宏定义：代码中已经说明清楚，这里不再累述。

        9二叉树的三种遍历操作：先序遍历、中序遍历和后序遍历。(放在后面说明)

 

        三、实现二叉树

        1、二叉树初始化的实现(bitree_init)

[cpp] view plaincopy

1. /* 
2.  * filename: bitree.c 
3.  * author: zhm 
4.  * date: 2012-01-08 
5.  */  
6.   
7. #include <string.h>  
8. #include <stdlib.h>  
9.   
10. #include "bitree.h"  
11.   
12. /* bitree_init */  
13. void bitree_init( BiTree *tree, void (*destroy)(void *data) )  
14. {  
15.     /* Initialize the binary tree */  
16.     tree->size = 0;  
17.     tree->root = NULL;  
18.     tree->destroy = destroy;  
19.     return;  
20. }  

        完成对维护二叉树结构体的各域值的初始化。

        2、二叉树的销毁操作(bitree_destroy)

[cpp] view plaincopy

1. /* bitree_destroy */  
2. void bitree_destroy(BiTree *tree)  
3. {  
4.     /* Remove all the nodes from the tree */  
5.     bitree_rem_left(tree, NULL);  
6.   
7.     memset(tree, 0, sizeof(BiTree) );  
8.     return;  
9. }  

        先删除二叉树的所有结点，然后清空二叉树结构体。

        3、二叉树插入操作(bitree_ins_left及bitree_ins_right)

        先是插入左子树操作：

[cpp] view plaincopy

1. /* bitree_ins_left */  
2. int bitree_ins_left(BiTree *tree, BiTreeNode *node, const void *data)  
3. {  
4.     BiTreeNode *new_node, **position;  
5.       
6.     if( node == NULL )  
7.     {  
8.         if( bitree_size(tree) > 0 )  
9.             return -1;  
10.   
11.         position = &tree->root;  
12.     }  
13.     else  
14.     {  
15.         if( bitree_left(node) != NULL )  
16.             return -1;  
17.           
18.         position = &node->left;  
19.     }  
20.   
21.     /* Allocate storage for the node */  
22.     new_node = (BiTreeNode *)malloc(sizeof(BiTreeNode));  
23.     if( new_node == NULL )  
24.         return -1;  
25.   
26.     /* insert the node into the tree */  
27.     new_node->data = (void *)data;  
28.     new_node->left = NULL;  
29.     new_node->right = NULL;  
30.       
31.     *position = new_node;  
32.   
33.     tree->size++;  
34.       
35.     return 0;  
36. }  

        接着是插入右子树操作：

[cpp] view plaincopy

1. /* bitree_ins_right */  
2. int bitree_ins_right(BiTree *tree, BiTreeNode *node, const void *data)  
3. {  
4.     BiTreeNode *new_node, **position;  
5.   
6.     if( node == NULL )  
7.     {  
8.         if( bitree_size(tree) > 0 )  
9.             return -1;  
10.           
11.         position = &tree->root;  
12.     }  
13.     else  
14.     {  
15.         if( bitree_right(node) != NULL )  
16.             return -1;  
17.   
18.         position = &node->right;  
19.     }  
20.   
21.     /* allocate the storage for the node. */  
22.     new_node = (BiTreeNode *)malloc(sizeof(BiTreeNode));  
23.     if( new_node == NULL )  
24.         return -1;  
25.   
26.     new_node->data = (void *)data;  
27.     new_node->left = NULL;  
28.     new_node->right = NULL;  
29.   
30.     *position = new_node;  
31.       
32.     tree->size++;  
33.     return 0;  
34. }  

        通过代码可以看出，这两个函数的实现几乎一样，我们这里只需要学会其内在思想：

        (1) 找准需要插入的位置：是在根结点位置，当前结点的左指针还是右指针位置。

        (2) 分配新结点，在适当的地方插入结点： *position = new_node完成了这个插入操作

        (3) 更新二叉树size域。

        4、二叉树删除操作(bitree_rem_left及bitre_rem_right)

        先是删除左子树操作：

[cpp] view plaincopy

1. /* bitree_rem_left */  
2. void bitree_rem_left(BiTree *tree, BiTreeNode *node)  
3. {  
4.     BiTreeNode **position;  
5.   
6.     /* Do not allow removal from an empty tree. */  
7.     if( bitree_size(tree) == 0 )  
8.         return;  
9.   
10.     if( node == NULL )  
11.     {  
12.         position = &tree->root;  
13.     }  
14.     else  
15.     {  
16.         position = &node->left;  
17.     }  
18.   
19.     /* Remove the nodes. */  
20.     if( *position != NULL )  
21.     {  
22.         bitree_rem_left(tree, *position);  
23.         bitree_rem_right(tree, *position);  
24.   
25.         if( tree->destroy != NULL )  
26.         {  
27.             tree->destroy((*position)->data);  
28.         }  
29.         free(*position);  
30.         *position = NULL;  
31.   
32.         /* adjust the size */  
33.         tree->size--;  
34.     }  
35.     return;  
36. }  

        接着是删除右子树操作：

[cpp] view plaincopy

1. /* bitree_rem_right */  
2. void bitree_rem_right(BiTree *tree, BiTreeNode *node)  
3. {  
4.     BiTreeNode **position;  
5.   
6.     if( bitree_size(tree) == 0 )  
7.         return;  
8.   
9.     if( node == NULL )  
10.     {  
11.         position = &tree->root;  
12.     }  
13.     else  
14.     {  
15.         position = &node->right;  
16.     }  
17.   
18.     /* Remove the nodes */  
19.     if( *position != NULL )  
20.     {  
21.         bitree_rem_left(tree, *position);  
22.         bitree_rem_right(tree, *position);  
23.   
24.         if( tree->destroy != NULL )  
25.         {  
26.             tree->destroy((*position)->data);  
27.         }  
28.   
29.         free(*position);  
30.         *position = NULL;  
31.         tree->size--;  
32.     }  
33.   
34.     return;  
35. }  

        同样的，我们需要掌握其实现的思想：

        通过采用递归的思想，后序遍历逐层深入到最底层（深度优先搜索），从下至上逐一删除各个结点，释放被删除结点的数据域空间，更新二叉树size值大小。注意递归退出的条件:

        (1) 树为空时退出

        (2) *Position为空时退出

        可以思考：为何删除操作不能采用前序或中序遍历？

        5、二叉树的合并(bitree_merge)

[cpp] view plaincopy

1. /* bitree_merge */  
2. int bitree_merge(BiTree *merge, BiTree *left, BiTree *right, const void *data)  
3. {  
4.     /* Initialize the merged tree. */  
5.     bitree_init(merge, left->destroy);  
6.   
7.     /* Insert the data for the root node of the merged tree */  
8.     if( bitree_ins_left(merge, NULL, data) != 0 )  
9.     {  
10.         bitree_destroy(merge);  
11.         return -1;  
12.     }  
13.   
14.     /* Merge the two binary trees into a single binary tree */  
15.     bitree_root(merge)->left = bitree_root(left);  
16.     bitree_root(merge)->right = bitree_root(right);  
17.       
18.     /* Adjust the size of the new tree */  
19.     merge->size = merge->size + bitree_size(left) + bitree_size(right);  
20.   
21.     /* Do not let the original trees access the merged nodes. */  
22.     left->root = NULL;  
23.     left->size = 0;  
24.     right->root = NULL;  
25.     right->size = 0;  
26.   
27.     return 0;  
28. }  

        二叉树的合并操作非常简单，有以下几个步骤：

        (1) 初始化新二叉树,并插入data域成为新二叉树的根结点

        (2) 新二叉树的左指针指向左子树的根结点

        (3) 新二叉树的右指针指向右子树的根结点

        (4) 新二叉树结点个数 =左、右子树结点之和+1

        (5) 对原左、右子树结构体相关域的清空操作。

 

        四、遍历二叉树

        遍历二叉树是指按照一定的规律，对二叉树的每个结点访问且仅访问一次的处理过程。这里的“访问”是泛指对结点数据的某种处理操作，如可以是printf打印显示，可以是链表的插入操作，也可以是某些数学运算，等等。

        遍历的目的：通过一次遍历后，可以使树中结点的非线性结构按访问的先后顺序转变为某种线性序列。如：可以按照访问的先后顺序将数据域逐一填入某一数组中，当然，也可以插入某个链表中，然后通过链表的方式对数据域进行访问。

        遍历的次序: DLR先序遍历、LDR中序遍历、LRD后序遍历

        可以看出，先、中、后序的遍历主要根据根结点的访问次序命名，而L左结点总是先于R右结点访问。无论是哪种遍历方式，其核心的思想是总是递归，以中序遍历二叉树为例，说明其算法思想：

        若二叉树非空，则：

        1)中序遍历左子树

        2)访问根结点

        3)中序遍历右子树

 

        (1)先序遍历二叉树

[cpp] view plaincopy

1. /* preorder */  
2. int preorder(const BiTreeNode *node, List *list)  
3. {  
4.     if( !bitree_is_eob(node) )  
5.     {  
6.       
7.         if( list_ins_next(list, list_tail(list), bitree_data(node) ) != 0 )  
8.         {  
9.             return -1;  
10.         }  
11.           
12.         if( !bitree_is_eob( bitree_left(node) ) )  
13.         {  
14.             if( preorder(bitree_left(node), list) != 0 )  
15.                 return -1;  
16.         }  
17.           
18.         if( !bitree_is_eob( bitree_right(node) ) )  
19.         {  
20.             if( preorder(bitree_right(node), list) != 0 )  
21.                 return -1;  
22.         }  
23.     }  
24.     return 0;  
25. }  

        (2)中序遍历二叉树

[html] view plaincopy

1. /* inorder */  
2. int inorder(const BiTreeNode *node, List *list)  
3. {  
4.     if( !bitree_is_eob(node) )  
5.     {  
6.         if( !bitree_is_eob(bitree_left(node)) )  
7.         {  
8.             if( inorder( bitree_left(node), list ) != 0 )  
9.                 return -1;  
10.         }  
11.           
12.         if( list_ins_next(list, list_tail(list), bitree_data(node)) != 0 )  
13.         {  
14.             return -1;  
15.         }  
16.           
17.         if( !bitree_is_eob(bitree_right(node)) )  
18.         {  
19.             if( inorder( bitree_right(node), list ) != 0 )  
20.                 return -1;  
21.         }  
22.     }  
23.     return 0;  
24. }  

        (3)后序遍历二叉树

[cpp] view plaincopy

1. /* postorder */  
2. int postorder(const BiTreeNode *node, List *list)  
3. {  
4.     if( !bitree_is_eob(node) )  
5.     {  
6.         if( !bitree_is_eob(bitree_left(node)) )  
7.         {  
8.             if( postorder(bitree_left(node), list) != 0 )  
9.                 return -1;  
10.         }  
11.           
12.         if( !bitree_is_eob(bitree_right(node)) )  
13.         {  
14.             if( postorder(bitree_right(node), list) != 0 )  
15.                 return -1;  
16.         }  
17.           
18.         if( list_ins_next(list, list_tail(list), bitree_data(node)) != 0 )  
19.             return -1;  
20.     }  
21.   
22.     return 0;  
23. }  

          在本例的三种遍历代码中，“访问”的方式是将结点的数据域插入至某一链表结构中。

        五、二叉树简单应用

        对上述所有二叉树的代码如果未进行使用或验证，无疑是一些基本符号，没有任何的意义，所以本节主要对前面二叉树的各个接口进行简单的应用测试，在进入实际的应用之前，有几个函数需要先实现，如下：

[cpp] view plaincopy

1. /* destroy */  
2. void destroy(void *data)  
3. {  
4.     free(data);  
5.     return;  
6. }  

        这是创建销毁函数的代码，在bitree_init()初始化二叉树时需要传递它的函数入口地址。接着是创建二叉树的函数：

[cpp] view plaincopy

1. /* create_tree */  
2. int create_tree(BiTree *tree, BiTreeNode *node)  
3. {  
4.       
5.     int ret;  
6.     int *int_ptr = NULL;  
7.     char ch;  
8.       
9.     scanf("%c", &ch);  
10.   
11.     if( ch == '#' )  
12.     {  
13.         return 0;  
14.     }  
15.     int_ptr = (int *)malloc(sizeof(int));  
16.     if( int_ptr == NULL )  
17.         return -1;  
18.   
19.     *int_ptr = ch-48;  
20.   
21.     if( node == NULL )  
22.     {  
23.         bitree_init(tree, destroy);  
24.         ret = bitree_ins_left(tree, NULL, (void *)int_ptr);  
25.         if( ret != 0 )  
26.         {  
27.             free(int_ptr);  
28.             return -1;  
29.         }  
30.         printf("root is %d\n", *(int *)bitree_data(tree->root));  
31.         create_tree(tree, tree->root);  
32.     }  
33.     else  
34.     {  
35.         //insert the data into left tree   
36.         ret = bitree_ins_left(tree, node, (void *)int_ptr);  
37.         if( ret != 0 )  
38.         {  
39.             free(int_ptr);  
40.             return -1;  
41.         }  
42.         printf("node: %d  's left node is :%d\n", *(int *)bitree_data(node), *(int *)bitree_data(node->left));  
43.         ret = create_tree(tree, node->left);  
44.   
45.         scanf("%c", &ch);  
46.   
47.         if( ch == '#')  
48.             return 0;  
49.   
50.         int_ptr = (int *)malloc(sizeof(int));  
51.         if( int_ptr == NULL )  
52.             return -1;  
53.   
54.         *int_ptr = ch-48;  
55.         // insert the data into right tree.  
56.         ret = bitree_ins_right(tree, node, (void *)int_ptr);  
57.         if( ret != 0 )  
58.         {  
59.             free(int_ptr);  
60.             return -1;  
61.         }  
62.         printf("node: %d  's right node is :%d\n", *(int *)bitree_data(node), *(int *)bitree_data(node->right));  
63.         ret = create_tree(tree, node->right);  
64.     }  
65.   
66.     return 0;  
67. }  

        它的实现逻辑比较简单，在于采用递归的思想来创建一棵二叉树，并且其递归退出的条件是输入“#”符号，注意：本代码的实现只能插入简单的数字（范围0-9），这对于简单测试来说已经足够了。

        下面是具体的关于二叉树各接口代码的简单测试应用，如下：

  

[cpp] view plaincopy

1. /* main */  
2. int main(int argc, char **argv)  
3. {  
4.     int ret;  
5.     int *int_ptr;  
6.     BiTree tree1, tree2, tree_merge;  
7.     List list;  
8.     ListElmt *member;  
9.     BiTreeNode *nd;  
10.   
11.     /* tree1 as follows : 
12.                 1 
13.               /   \ 
14.              2     5 
15.             / \   / \ 
16.            3  4  6   7 
17.     */  
18.     create_tree(&tree1, NULL); //input "123#4#56#7#"  
19.     printf("\nstep1:tree1 build success\n");  
20.   
21.     /* tree2 as follows:       
22.                 0 
23.               /   \ 
24.              8     9 
25.             / \   /  
26.            6   7 3 
27.      */  
28.     int_ptr = NULL;  
29.     create_tree(&tree2, NULL); //input "086#7#93###"  
30.     printf("step2:tree2 build success\n");  
31.   
32.     int_ptr = (int *)malloc(sizeof(int));  
33.     if( int_ptr == NULL )  
34.         return -1;  
35.     *int_ptr = 11;  
36.    
37.     /* after merged as follow( by tree1 and tree2 ) : 
38.                                 11 
39.                           /             \ 
40.                          1               0 
41.                      /       \         /    \ 
42.                     2         5       8      9 
43.                  /    \    /    \   /   \   /  \ 
44.                 3      4  6      9 6     7 3    NULL 
45.     */  
46.     ret = bitree_merge(&tree_merge, &tree1, &tree2, int_ptr);  
47.     printf("step3: after merged: there are %d number nodes in the tree_merge.\n", bitree_size(&tree_merge));  
48.       
49.   
50.     /* after remove the right tree: 
51.                    11  
52.                  /   \ 
53.                 1     NULL 
54.               /   \ 
55.              2     5 
56.             / \   / \ 
57.            3  4  6   7 
58.      */                     
59.     printf("\nstep4: remove the right tree in tree_merge.\n");  
60.     bitree_rem_right(&tree_merge,  bitree_root(&tree_merge) );  
61.     printf("after remove the right tree, there are %d number nodes in the tree_merge.\n", bitree_size(&tree_merge));  
62.       
63.     printf("\nstep5: preorder traverse the tree and insert the nodes into the list\n");  
64.     list_init(&list, destroy);  
65.     ret = preorder( bitree_root(&tree_merge), &list );  
66.   
67.     printf("according to the sequence of the preorder traversing the tree:\n");  
68.     for(member = list_head(&list); member != NULL; member = list_next(member) )  
69.     {  
70.        printf("%d ", *(int *)list_data(member));   
71.     }  
72.     printf("\n");  
73.   
74.   
75.     printf("\nsetp6: inorder traverse the tree and insert the nodes into the list\n");  
76.     list_init(&list, destroy);  
77.   
78.     ret = inorder( bitree_root(&tree_merge), &list );  
79.   
80.     printf("according to the sequence of the inorder traversing the tree:\n");  
81.     for(member = list_head(&list); member != NULL; member = list_next(member) )  
82.     {  
83.        printf("%d ", *(int *)list_data(member));   
84.     }  
85.     printf("\n");  
86.   
87.     printf("\nsetp7: postorder traverse the tree and insert the nodes into the list\n");  
88.     list_init(&list, destroy);  
89.       
90.     ret = postorder( bitree_root(&tree_merge), &list );  
91.     printf("according to the sequence of the postorder traversing the tree:\n");  
92.     for(member = list_head(&list); member != NULL; member = list_next(member) )  
93.     {  
94.        printf("%d ", *(int *)list_data(member));   
95.     }  
96.     printf("\n");  
97.   
98.     printf("\nstep8: delete all the nodes in the tree.\n");  
99.     bitree_rem_left( &tree_merge, NULL );  
100.     printf("there are %d number nodes.\n", bitree_size(&tree_merge) );  
101.       
102.     bitree_destroy(&tree_merge);  
103.   
104.     return 0;  
105. }  

        具体的含义不再说明，注释以及printf已经非常详细。代码的编译过程如下：

        程序执行过程如下：