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

在cpp中使用的C语言

头文件

 /* 有序二叉树 BsTree */
 #ifndef _BT_H
 #define _BT_H
 /*节点*/
 typedef struct BsTreeNode
 {
     int                    data;/* 数据 */
     struct BsTreeNode*  left;/* 左子树 */
     struct BsTreeNode*  right;/* 右子树 */
 }BSTREE_NODE;
 /* 二叉树 */
 typedef struct BsTree
 {
     BSTREE_NODE* root;/* 树根 */
     size_t       size;/* 大小 */
 }BSTREE;
 /* 初始化为空树 */
 void bstree_init(BSTREE* bstree);
 /* 释放剩余节点并恢复到初始状态 */
 void bstree_deinit(BSTREE* bstree);
 /* 插入 */
 void bstree_insert(BSTREE* bstree, int data);
 /* 删除 */
 bool bstree_erase(BSTREE* bstree, int data);
 /* 删除所有匹配数据 */
 void bstree_remove(BSTREE* bstree, int data);
 /* 清空 */
 void bstree_clear(BSTREE* bstree);
 /* 更新 */
 void bstree_update(BSTREE* bstree, int _old, int _new);
 /* 判断是否存在 */
 bool bstree_exist(BSTREE* bstree, int data);
 /* 中序遍历 */
 void bstree_travel(BSTREE* bstree);
 /* 大小 */
 size_t bstree_size(BSTREE* bstree);
 /* 高度 */
 size_t bstree_height(BSTREE* bstree);
 #endif /*_BT_H*/

实现

 /* 有序二叉树 */
 #include <stdio.h>
 #include <stdlib.h>
 #include "bt.h"

 /*********************** 内 部 接 口 ********************************/
 /* 创建节点 */
 static BSTREE_NODE* create_node(int data)
 {
     BSTREE_NODE* node = (BSTREE_NODE*)malloc(sizeof(BSTREE_NODE));
     node->data = data;
     node->left = NULL;
     node->right = NULL;
     return node;
 }
 /* 销毁节点 */
 static void destory_node(BSTREE_NODE* node)
 {
     free(node);
 }
 /* 将node节点插入到以root为根的子树中 */
 static void insert(BSTREE_NODE* node, BSTREE_NODE** root)
 {
     if ( NULL == *root )
         *root = node;
     else if (node)
     {
         if ( node->data < (*root)->data )
             insert(node, &((*root)->left));
         else
             insert(node, &((*root)->right));
     }
 }
 /* 返回以参数root为根的子树中，数据与参数data匹配的节点的父节点中
 *  指向该节点的指针型成员变量的地址
 *  目的是在删除节点后，要将删除节点的子节点接到此变量的地址上。
 */
 static BSTREE_NODE** find(int data, BSTREE_NODE** root)
 {
     if (NULL == *root)
         return root;
     if (data < (*root)->data)
         return find(data, &(*root)->left);
     if (data > (*root)->data)
         return find(data, &(*root)->right);
     return root;
 }
 /* 删除以参数root为根的子树 */
 static void clear(BSTREE_NODE** root)
 {
     if (*root)
     {
         clear(&(*root)->left);
         clear(&(*root)->right);
         destory_node(*root);
         *root = NULL;
     }
 }
 /* 中序遍历以参数root为根的子树 */
 static void travel(BSTREE_NODE* root)
 {
     if (root)
     {
         travel(root->left);
         printf("%d ", root->data);
         travel(root->right);
     }
 }
 /* 返回以参数root为根的子树的高度 */
 static size_t height(BSTREE_NODE* root)
 {
     if (root)
     {
         size_t lh = height(root->left);
         size_t rh = height(root->right);
         return (((lh > rh) ? lh : rh) + );
     }
     return ;
 }
 /*********************** 外 部 接 口 ********************************/
 /* 初始化为空树 */
 void bstree_init(BSTREE* bstree)
 {
     bstree->root = NULL;
     bstree->size = ;
 }
 /* 释放剩余节点并恢复到初始状态 */
 void bstree_deinit(BSTREE* bstree)
 {
     clear(&bstree->root);
     bstree->size = ;
 }
 /* 插入 */
 void bstree_insert(BSTREE* bstree, int data)
 {
     insert(create_node(data), &bstree->root);
     ++bstree->size;
 }
 /* 删除 */
 bool bstree_erase(BSTREE* bstree, int data)
 {
     BSTREE_NODE** node = find(data, &bstree->root);
     if (*node)
     {
         /* 将匹配节点的左子树插入其右子树 */
         insert((*node)->left, &(*node)->right);
         BSTREE_NODE* tmp = *node;
         /* 用匹配节点的右子树的根节点取代匹配节点 */
         *node = (*node)->right;
         /* 销毁匹配节点 */
         destory_node(tmp);
         --bstree->size;
         return true;
     }
     return false;
 }
 /* 删除所有匹配数据 */
 void bstree_remove(BSTREE* bstree, int data)
 {
     while(bstree_erase(bstree, data));
 }
 /* 清空 */
 void bstree_clear(BSTREE* bstree)
 {
     bstree_deinit(bstree);
 }
 /* 更新 */
 void bstree_update(BSTREE* bstree, int _old, int _new)
 {
     while(bstree_erase(bstree, _old))
         bstree_insert(bstree, _new);
 }
 /* 判断是否存在 */
 bool bstree_exist(BSTREE* bstree, int data)
 {
     return *find(data, &bstree->root) != NULL;
 }
 /* 中序遍历 */
 void bstree_travel(BSTREE* bstree)
 {
     travel(bstree->root);
     printf("\n");
 }
 /* 大小 */
 size_t bstree_size(BSTREE* bstree)
 {
     return bstree->size;
 }
 /* 高度 */
 size_t bstree_height(BSTREE* bstree)
 {
     return height(bstree->root);
 }

测试用例

 /* 有序二叉树 */
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 #include "bt.h"

 int main ()
 {
     srand((unsigned)time(NULL));
     BSTREE bstree;
     bstree_init(&bstree);
     int i;
     for (i = ; i < ; ++i)
         bstree_insert(&bstree, rand()%);

     bstree_travel(&bstree);
     bstree_clear(&bstree);
     bstree_insert(&bstree, );
     bstree_insert(&bstree, );
     bstree_insert(&bstree, );
     bstree_insert(&bstree, );
     bstree_insert(&bstree, );
     bstree_insert(&bstree, );
     bstree_insert(&bstree, );
     bstree_insert(&bstree, );
     bstree_insert(&bstree, );
     bstree_travel(&bstree);
     printf("大小：%u\n树高：%u\n",
         bstree_size(&bstree), bstree_height(&bstree));

     bstree_erase(&bstree, );
     bstree_travel(&bstree);
     bstree_insert(&bstree, );
     bstree_insert(&bstree, );
     bstree_travel(&bstree);
     bstree_update(&bstree, , );
     bstree_travel(&bstree);
     bstree_remove(&bstree, );
     bstree_travel(&bstree);
     if (bstree_exist(&bstree, /**/))
         printf("有！\n");
     else
         printf("没有！\n");

     bstree_deinit(&bstree);
     system("pause");
     return ;
 }

练习：（一般的二叉树）

已知某二叉树前序遍历的结果为：1 2 4 7 3 5 6 8

　　　　　　中序遍历的结果为：4 7 2 1 5 3 8 6

编写三个函数分别用于重建二叉树、前序遍历和中序遍历。