C语言实现有序二叉树（1）

 1 /* 有序二叉树 BsTree */
 2 #ifndef _BT_H
 3 #define _BT_H
 4 /*节点*/
 5 typedef struct BsTreeNode
 6 {
 7     int                    data;/* 数据 */
 8     struct BsTreeNode*  left;/* 左子树 */
 9     struct BsTreeNode*  right;/* 右子树 */
10 }BSTREE_NODE;
11 /* 二叉树 */
12 typedef struct BsTree
13 {
14     BSTREE_NODE* root;/* 树根 */
15     size_t       size;/* 大小 */
16 }BSTREE;
17 /* 初始化为空树 */
18 void bstree_init(BSTREE* bstree);
19 /* 释放剩余节点并恢复到初始状态 */
20 void bstree_deinit(BSTREE* bstree);
21 /* 插入 */
22 void bstree_insert(BSTREE* bstree, int data);
23 /* 删除 */
24 bool bstree_erase(BSTREE* bstree, int data);
25 /* 删除所有匹配数据 */
26 void bstree_remove(BSTREE* bstree, int data);
27 /* 清空 */
28 void bstree_clear(BSTREE* bstree);
29 /* 更新 */
30 void bstree_update(BSTREE* bstree, int _old, int _new);
31 /* 判断是否存在 */
32 bool bstree_exist(BSTREE* bstree, int data);
33 /* 中序遍历 */
34 void bstree_travel(BSTREE* bstree);
35 /* 大小 */
36 size_t bstree_size(BSTREE* bstree);
37 /* 高度 */
38 size_t bstree_height(BSTREE* bstree);
39 #endif /*_BT_H*/

  1 /* 有序二叉树 */
  2 #include <stdio.h>
  3 #include <stdlib.h>
  4 #include "bt.h"
  5 
  6 /*********************** 内 部 接 口 ********************************/
  7 /* 创建节点 */
  8 static BSTREE_NODE* create_node(int data)
  9 {
 10     BSTREE_NODE* node = (BSTREE_NODE*)malloc(sizeof(BSTREE_NODE));
 11     node->data = data;
 12     node->left = NULL;
 13     node->right = NULL;
 14     return node;
 15 }
 16 /* 销毁节点 */
 17 static void destory_node(BSTREE_NODE* node)
 18 {
 19     free(node);
 20 }
 21 /* 将node节点插入到以root为根的子树中 */
 22 static void insert(BSTREE_NODE* node, BSTREE_NODE** root)
 23 {
 24     if ( NULL == *root )
 25         *root = node;
 26     else if (node)
 27     {
 28         if ( node->data < (*root)->data )
 29             insert(node, &((*root)->left));
 30         else
 31             insert(node, &((*root)->right));
 32     }
 33 }
 34 /* 返回以参数root为根的子树中，数据与参数data匹配的节点的父节点中
 35 *  指向该节点的指针型成员变量的地址
 36 *  目的是在删除节点后，要将删除节点的子节点接到此变量的地址上。
 37 */
 38 static BSTREE_NODE** find(int data, BSTREE_NODE** root)
 39 {
 40     if (NULL == *root)
 41         return root;
 42     if (data < (*root)->data)
 43         return find(data, &(*root)->left);
 44     if (data > (*root)->data)
 45         return find(data, &(*root)->right);
 46     return root;
 47 }
 48 /* 删除以参数root为根的子树 */
 49 static void clear(BSTREE_NODE** root)
 50 {
 51     if (*root)
 52     {
 53         clear(&(*root)->left);
 54         clear(&(*root)->right);
 55         destory_node(*root);
 56         *root = NULL;
 57     }
 58 }
 59 /* 中序遍历以参数root为根的子树 */
 60 static void travel(BSTREE_NODE* root)
 61 {
 62     if (root)
 63     {
 64         travel(root->left);
 65         printf("%d ", root->data);
 66         travel(root->right);
 67     }
 68 }
 69 /* 返回以参数root为根的子树的高度 */
 70 static size_t height(BSTREE_NODE* root)
 71 {
 72     if (root)
 73     {
 74         size_t lh = height(root->left);
 75         size_t rh = height(root->right);
 76         return (((lh > rh) ? lh : rh) + 1);
 77     }
 78     return 0;
 79 }
 80 /*********************** 外 部 接 口 ********************************/
 81 /* 初始化为空树 */
 82 void bstree_init(BSTREE* bstree)
 83 {
 84     bstree->root = NULL;
 85     bstree->size = 0;
 86 }
 87 /* 释放剩余节点并恢复到初始状态 */
 88 void bstree_deinit(BSTREE* bstree)
 89 {
 90     clear(&bstree->root);
 91     bstree->size = 0;
 92 }
 93 /* 插入 */
 94 void bstree_insert(BSTREE* bstree, int data)
 95 {
 96     insert(create_node(data), &bstree->root);
 97     ++bstree->size;
 98 }
 99 /* 删除 */
100 bool bstree_erase(BSTREE* bstree, int data)
101 {
102     BSTREE_NODE** node = find(data, &bstree->root);
103     if (*node)
104     {
105         /* 将匹配节点的左子树插入其右子树 */
106         insert((*node)->left, &(*node)->right);
107         BSTREE_NODE* tmp = *node;
108         /* 用匹配节点的右子树的根节点取代匹配节点 */
109         *node = (*node)->right;
110         /* 销毁匹配节点 */
111         destory_node(tmp);
112         --bstree->size;
113         return true;
114     }
115     return false;
116 }
117 /* 删除所有匹配数据 */
118 void bstree_remove(BSTREE* bstree, int data)
119 {    
120     while(bstree_erase(bstree, data));
121 }
122 /* 清空 */
123 void bstree_clear(BSTREE* bstree)
124 {
125     bstree_deinit(bstree);
126 }
127 /* 更新 */
128 void bstree_update(BSTREE* bstree, int _old, int _new)
129 {
130     while(bstree_erase(bstree, _old))
131         bstree_insert(bstree, _new);
132 }
133 /* 判断是否存在 */
134 bool bstree_exist(BSTREE* bstree, int data)
135 {
136     return *find(data, &bstree->root) != NULL;
137 }
138 /* 中序遍历 */
139 void bstree_travel(BSTREE* bstree)
140 {
141     travel(bstree->root);
142     printf("\n");
143 }
144 /* 大小 */
145 size_t bstree_size(BSTREE* bstree)
146 {
147     return bstree->size;
148 }
149 /* 高度 */
150 size_t bstree_height(BSTREE* bstree)
151 {
152     return height(bstree->root);
153 }

 1 /* 有序二叉树 */
 2 #include <stdio.h>
 3 #include <stdlib.h>
 4 #include <time.h>
 5 #include "bt.h"
 6 
 7 int main ()
 8 {
 9     srand((unsigned)time(NULL));
10     BSTREE bstree;
11     bstree_init(&bstree);
12     int i;
13     for (i = 0; i < 10; ++i)
14         bstree_insert(&bstree, rand()%100);
15 
16     bstree_travel(&bstree);
17     bstree_clear(&bstree);
18     bstree_insert(&bstree, 50);
19     bstree_insert(&bstree, 70);
20     bstree_insert(&bstree, 20);
21     bstree_insert(&bstree, 60);
22     bstree_insert(&bstree, 40);
23     bstree_insert(&bstree, 30);
24     bstree_insert(&bstree, 10);
25     bstree_insert(&bstree, 90);
26     bstree_insert(&bstree, 80);
27     bstree_travel(&bstree);
28     printf("大小：%u\n树高：%u\n", 
29         bstree_size(&bstree), bstree_height(&bstree));
30 
31     bstree_erase(&bstree, 20);
32     bstree_travel(&bstree);
33     bstree_insert(&bstree, 70);
34     bstree_insert(&bstree, 70);
35     bstree_travel(&bstree);
36     bstree_update(&bstree, 70, 200);
37     bstree_travel(&bstree);
38     bstree_remove(&bstree, 200);
39     bstree_travel(&bstree);
40     if (bstree_exist(&bstree, /*20*/40))
41         printf("有！\n");
42     else
43         printf("没有！\n");
44 
45     bstree_deinit(&bstree);
46     system("pause");
47     return 0; 
48 }