在cpp中使用的C语言
头文件
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 }
练习：（一般的二叉树）
已知某二叉树前序遍历的结果为：1 2 4 7 3 5 6 8
中序遍历的结果为：4 7 2 1 5 3 8 6
编写三个函数分别用于重建二叉树、前序遍历和中序遍历。
时间： 2024-10-21 22:48:44