C语言二叉树搜索（BST）相关练习

最新推荐文章于 2021-11-20 11:54:05 发布
最新推荐文章于 2021-11-20 11:54:05 发布
阅读量442 收藏
点赞数
文章标签： C语言 二叉树 重新排列 中序遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20461063/article/details/79190930
版权

最近学习了二叉搜索树的相关知识，练习写了关于为二叉搜索树实现一个抽象数据类型（ADT）的树（BST）。 BST以有序的方式存储密钥（左边的“更小”，右边的“更大的”根节点的权利）。 ADT的用户如何定义“更小”和“更大”界定。 没有关键词（key words）可以被存储两次，这里使用的BST不存储特定的类型，而是存储空间块指针。 比较两个不同的内存块的方式，比较或排序，是通过一个用户提供的功能，与qsort类似。功能：初始化，插入，最深路径，打印二叉树，中序遍历二叉树，重新平衡二叉树，释放二叉树缓存（为了避免内存遗漏Memory leak）

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#include "bst.h"

bst* bst_init(int sz,
              int(*comp)(const void* a, const void* b),
              char*(*prnt)(const void* a)  )
{
   bst *l;
   l = (bst*) calloc (1, sizeof(bst));
   if(l == NULL){
      ON_ERROR("创建二叉树失败\n");
   }
   l->top = NULL;
   l->elsz = sz;
   l->compare  = comp;
   l->prntnode = prnt;
   return l;
}

/*二叉树初始化*/
bstnode* createNode(bst *b)
{
   bstnode *l;
   l= (bstnode*) calloc (1, sizeof(bstnode));
   if(l == NULL){
      ON_ERROR("创建节点失败.\n");
   }
   l->data  = (bstnode*) calloc (1, b->elsz);
   l->left  = NULL;
   l->right = NULL;
   return l;
}

void insertBinTree(bst* b, bstnode *n, void* v)
{
   if((b->compare)(v,n->data) == 0) {
      return;
   }else if((b->compare)(v,n->data) < 0){
      if(n->left == NULL){
         n->left = createNode(b);
         memcpy(n->left->data, v, b->elsz);
      }else{
         insertBinTree(b, n->left, v);
      }
   }else{
      if(n->right == NULL){
         n->right = createNode(b);
         memcpy(n->right->data, v, b->elsz);
      }else{
         insertBinTree(b, n->right, v);
      }
   }
}

void bst_insert(bst* b, void* v)
{
   if(b == NULL){ 
      return; 
   }else{
      if(b->top == NULL){
         b->top = createNode(b);
         memcpy(b->top->data, v, b->elsz);
      }else{
         insertBinTree(b, b->top, v);     
      }
   }
}

/* 二叉树中总结点计算 */
int node_sum(bstnode *n)
{
   int sum;
   sum = 0;
   if(n == NULL){
      return sum;
   }else{
      sum++;
      return (sum + node_sum(n->left) + node_sum(n->right)); 
   }
}

int bst_size(bst* b)
{
   if(b==NULL || b->top == NULL){
      return 0;
   }
   return node_sum(b->top);
}

/* 最深路径 */
int node_depth(bstnode *n)
{
   int leftdep = 0;
   int rightdep = 0;

   if(n->left != NULL){
      leftdep = node_depth(n->left);
   }
   if(n->right != NULL){
      rightdep = node_depth(n->right);
   }
   return (leftdep > rightdep) ? leftdep+1 : rightdep+1;
}

int bst_maxdepth(bst* b)
{
   if(b== NULL|| b->top == NULL){
      return 0;
   }
   return node_depth(b->top);
}

/* 搜索void v 是否存在二叉树中 */
int inTree(bst* b, bstnode* n, void* v)
{
   if(n == NULL){ 
      return false;
   }
   if((b->compare)(v,n->data) == 0){ 
      return true; 
   }
   if((b->compare)(v,n->data) < 0){
      return inTree(b, n->left, v);
   }
   else{
      return inTree(b, n->right, v);
   }
}

bool bst_isin(bst* b, void* v)
{
   if(b == NULL || b->top == NULL){
      return false;
   }
   return inTree(b, b->top, v);
}

/*把n个数组插入二叉树中去*/
void bst_insertarray(bst* b, void* v, int n)
{
  int i;
  char *p;
  p = v;
  if(b == NULL || v == NULL){
     return;
  }
  for(i = 0; i < n; i++){
     bst_insert(b, p + i*b->elsz);
  }    
}

/* 清除二叉树中的缓存*/
void node_free(bstnode *n)
{
   if(n != NULL){
      node_free(n->left);
      node_free(n->right);
      free(n->data);
      free(n);
      n = NULL;
   }
}
void bst_free(bst** p)
{
   bst* a = *p;
   node_free(a->top);
   free(a);
   *p = NULL;
}

/***************************/
/* 附加功能                */
/***************************/

/*打印二叉树*/
char* printbst(bst* b, bstnode* n, char* str)
{
   char *nstr;
   char *data;
   if(n != NULL){
      data = b->prntnode(n->data);
      nstr = (char *) calloc (1, strlen(data) +2);
      if(nstr == NULL){
         ON_ERROR("打印二叉树失败\n");
      }
      sprintf(nstr,"(%s", data);
      strcat(str, nstr);
      free(nstr);
      if(n->left != NULL){
         printbst(b, n->left, str);
      }
      if(n->right != NULL){
         printbst(b, n->right, str);
      }
      strcat(str,")");
   }
   return str;
}

char* bst_print(bst* b)
{
   char *str;
   char *data;
   if(b->top != NULL){
      data = b->prntnode(b->top->data);
      str = (char*) calloc (bst_size(b), (strlen(data)+2)+1);
      return printbst(b, b->top, str);
      free(str);
   }else{
      ON_ERROR("该二叉树为空\n");
   }
}

/*中序遍历二叉树并赋值到数组中去*/
void inorder(bst* b, bstnode* n, void* v, int *count)
{
   if(n != NULL){
      inorder(b, n->left, v, count);
      memcpy((char*)v+(*count)*b->elsz, n->data, b->elsz);
      (*count)++;
      inorder(b, n->right, v, count);
   }   
}

/* 按顺序读取二叉树并存在数组中去*/
void bst_getordered(bst* b, void* v)
{
   int *count;
   count=(int*) calloc (1, sizeof(int));
   if(count == NULL){
      ON_ERROR("创建计数器失败.\n");
   }
   *count = 0;
   if(b == NULL || v == NULL){
      return;
   }else{
   inorder(b, b->top, v, count);
   }
   free(count);
}

/*找到二叉树的中间节点*/
void middle_node(bst* l, void* v, int left, int right)
{
   int middle;
   if(left!=right){
      middle = (left + right)/2;
      bst_insert(l, (char*)v + (middle * l->elsz));
      middle_node(l, v, left, middle);
      middle_node(l, v, middle + 1, right);
   }
}

/* 重平衡二叉树*/
bst* bst_rebalance(bst* b)
{
   int size;
   void *v;
   bst* l;
   l = bst_init(b->elsz, b->compare, b->prntnode); 
   if(b !=NULL){
      size = bst_size(b);
      v = (void *) calloc (1, size*b->elsz); 
      if(v == NULL){
         ON_ERROR("重新排列二叉树失败.\n");
      }else{
         bst_getordered(b, v);
         middle_node(l, v, 0, size);
         free(v);
      }
   }
   return l;
}
在这里也贴出bst.h的文件 
#ifndef __BSTREE_H__
#define __BSTREE_H__

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define ON_ERROR(STR) fprintf(stderr, STR); exit(EXIT_FAILURE)

/*动态（不平衡）二进制搜索树，存储
    （void）指向数据的指针。 没有重复的东西可以存储*/

struct bstnode {
   void* data;
   struct bstnode* left;
   struct bstnode* right;
};
typedef struct bstnode bstnode;

struct bst {
   bstnode* top;
   /* 数据元素大小，以字节为单位*/
   int elsz;
   /* 就像qsort（）一样，传递一个可以比较两个数据项的函数*/
   int(*compare)(const void* a, const void* b);
   /* 传递一个可以将数据项返回为字符串的函数（用于打印）*/
   char*(*prntnode)(const void* a);
};
typedef struct bst bst;

bst* bst_init(int sz,
              int(*comp)(const void* a, const void* b),
              char*(*prnt)(const void* a)  );
/*在二叉树中插入数据*/
void bst_insert(bst* b, void* v);

/*二叉树中的节点数*/
int bst_size(bst* b);

/* 从根到任何叶的最长路径 */
int bst_maxdepth(bst* b);

/*v中的数据是否存储在树中 */
bool bst_isin(bst* b, void* v);

/* 批量插入数组v中的n个项目到初始化树中 */
void bst_insertarray(bst* b, void* v, int n);

/* 清除与树关联的所有内存，并将指针设置为NULL */
void bst_free(bst** p);

/***************************/
/*附加功能                 */
/***************************/

/* 返回以文本形式（头（左）（右））递归显示树的字符串*/
char* bst_print(bst* b);

/* 用排序树数据的副本填充数组*/
void bst_getordered(bst* b, void* v);

/* 重新平衡树，递归使用排序键的中位数*/
bst* bst_rebalance(bst* b);

#endif

对应的测试文件testbst.c, 用assert（）函数来测试具体代码内容 

#include "bst.h"
#include <time.h>
#include <assert.h>

#define STRSIZE 20
#define WORDS 23

int mystrcmp(const void* a, const void* b);
int mychrcmp(const void* a, const void* b);
int myintcmp(const void* a, const void* b);
char* myprintstr(const void* v);
char* myprintchr(const void* v);
char* myprintint(const void* v);

void test_simpleinsert(void);
void test_insertarray(void);
void test_getordered(void);
void test_print(void);
void test_rebalance(void);

int main(void)
{

   printf("Beginning BST Test ...\n");

   test_simpleinsert();
   test_insertarray();
   test_getordered();
   test_rebalance();
   test_print();

   printf("Finished BST Test ...\n");
   return 0;

}

void test_simpleinsert(void)
{
   char str[STRSIZE];
   bst* b;
   b = bst_init(STRSIZE, mystrcmp, myprintstr);
   assert(bst_size(b)==0);
   strcpy(str, "dog");
   bst_insert(b, str);
   assert(bst_size(b)==1);
   assert(bst_isin(b, str));
   strcpy(str, "apple");
   bst_insert(b, str);
   assert(bst_size(b)==2);
   assert(bst_isin(b, str));
   strcpy(str, "garage");
   bst_insert(b, str);
   assert(bst_size(b)==3);
   assert(bst_isin(b, str));
   strcpy(str, "baggage");
   bst_insert(b, str);
   assert(bst_size(b)==4);
   assert(bst_isin(b, str));
   strcpy(str, "baggage");
   bst_insert(b, str);
   assert(bst_size(b)==4);
   assert(bst_isin(b, str));
   strcpy(str, "igloo");
   bst_insert(b, str);
   assert(bst_size(b)==5);
   assert(bst_isin(b, str));
   strcpy(str, "cat");
   bst_insert(b, str);
   assert(bst_size(b)==6);
   assert(bst_isin(b, str));
   strcpy(str, "eccentric");
   bst_insert(b, str);
   assert(bst_size(b)==7);
   assert(bst_isin(b, str));
   strcpy(str, "fresian");
   bst_insert(b, str);
   assert(bst_size(b)==8);
   assert(bst_isin(b, str));
   strcpy(str, "hotel");
   bst_insert(b, str);
   assert(bst_size(b)==9);
   assert(bst_isin(b, str));
   strcpy(str, "jaguar");
   bst_insert(b, str);
   assert(bst_size(b)==10);
   assert(bst_isin(b, str));
   assert(bst_maxdepth(b)==4);

   bst_free(&b);
   assert(b==NULL);
}

void test_insertarray(void)
{
   char words1[WORDS][STRSIZE] = {"it", "is", "a", "truth", "universally", "acknowledged", "that",  "a", "single", "man", "in", "possession", "of", "a", "good", "fortune", "must", "be", "in", "want", "of", "a", "wife"};
   bst* b = bst_init(STRSIZE, mystrcmp, myprintstr);
   bst_insertarray(b, words1, WORDS);
   assert(bst_size(b)==18);
   bst_free(&b);
   assert(b==NULL);
}

void test_getordered(void)
{
   int i, sc;
   char words1[WORDS][STRSIZE] = {"it", "is", "a", "truth", "universally", "acknowledged", "that",  "a", "single", "man", "in", "possession", "of", "a", "good", "fortune", "must", "be", "in", "want", "of", "a", "wife"};
   char words2[WORDS][STRSIZE];
   bst* b = bst_init(STRSIZE, mystrcmp, myprintstr);
   bst_insertarray(b, words1, WORDS);
   assert(bst_size(b)==18);
   bst_getordered(b, words2);
   for(i=0; i<17; i++){
      sc = strcmp(words2[i], words2[i+1]);
      assert(sc<0);
   }
   bst_free(&b);
   assert(b==NULL);
}

void test_rebalance(void)
{
   int i;
   bst* b = bst_init(sizeof(int), myintcmp, myprintint);
   bst* rb;
   /* Sorted List, bad for building tree */
   for(i=0; i<2048; i++){
      bst_insert(b, &i);
   }
   assert(bst_maxdepth(b)==i);
   rb = bst_rebalance(b);
   assert(bst_maxdepth(rb)==12);
   bst_free(&b);
   bst_free(&rb);
}

void test_print(void)
{
   int i, sc;
   char istr[] = "MNKIDFGH";
   char pstr[] = "(M(K(I(D(F(G(H))))))(N))";
   char* ostr;
   bst* b;
   b = bst_init(sizeof(char), mychrcmp, myprintchr);
   assert(b!=NULL);
   assert(bst_size(b)==0);
   for(i=0; i<(int)strlen(istr); i++){
      bst_insert(b, &istr[i]);
      assert(bst_isin(b,&istr[i]));
      assert(bst_size(b)==(i+1));
   }
   ostr = bst_print(b);
   sc = strcmp(pstr,ostr);
   assert(sc==0);
   free(ostr);
   bst_free(&b);
}

char* myprintstr(const void* v)
{
   return (char*)v;
}

char* myprintchr(const void* v)
{
   static char str[100];
   sprintf(str, "%c", *(char*)v);
   return str;
}

char* myprintint(const void* v)
{
   static char str[100];
   sprintf(str, "%d", *(int*)v);
   return str;
}

int mystrcmp(const void* a, const void* b)
{
   return strcmp(a, b);
}

int mychrcmp(const void* a, const void* b)
{
   return *(char*)a - *(char*)b;
}

int myintcmp(const void* a, const void* b)
{
   return *(int*)a - *(int*)b;
}

本人新手小白，如果有什么还可以改进的地方，请大神多多指教。


小鼻涕泡儿zZ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【C语言】二叉树练习题
杨同学的博客
06-19 3542
本文练习题目： 单值二叉树 二叉树的最大深度 翻转二叉树 相同的树 对称二叉树 二叉树的前序遍历 另一棵树的子树 平衡二叉树 KY11 二叉树遍历如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树。只有给定的树是单值二叉树时，才返回 ；否则返回 。示例： 解答：思路：判断一整个树的值是否都相同，可以拆分成判断 根节点和左右子树的值是否相同，对每一个节点都和左右子树进行比较。让根节点和左右子树的值相比，如果不相等就返回false，如果相等就往下将左右子树的节点作为根节点递归下去，只要有一层返回fal
BST二叉树在C语言上的实现
go_sann
06-02 1498
题外话：二叉树的思想还是挺简单的，就是左右左右，主要问题点是实现过程中用到了二级指针。用二级指针的目的（虽然这里没有写出），是在搜索相同值的节点的时候，为了保存相同值节点的父节点，即相同值节点为*p，父节点为p；同时拥有p和*p，才能在建立新节点或者删除节点的时候建立联系。比如插入时new-&gt;left = NULL; new-&gt;right = NULL; new-&gt...
C语言实现搜索二叉树（无重复）
Synchro 明净翼 的博客
05-15 1198
        关于什么是搜索二叉树我就不介绍了，我主要讲实现的思路。我们来用这棵树来举例子        首先是搜索二叉树的添加 public void SearchTreeInsert(Search_Tree search_tree, int Key) throws Exception {//搜索二叉树插入 if (search_tree == null) { ...
[每日练习]C编程实现二叉树
WangMark的专栏
09-18 546
#include #include typedef struct _Btree {     int value;     struct _Btree *left;     struct _Btree *right; } Btree; void Btree_insert(Btree **node, int value) {     Btree *b = *node;
BST(二叉搜索树)练习
weixin_44272266的博客
11-20 542
学习东哥算法小抄笔记：文章链接 内容 二叉搜索树 中序遍历对BST的意义       二叉搜索树中第K小的元素       把二叉搜索树转换为累加树 BST基本操作       验证二叉搜索树       二叉搜索树中的搜索    &nb
C语言二叉树相关的代码.zip
10-28
本文将深入探讨C语言实现二叉树的相关知识点，包括二叉树的基本概念、常用操作以及如何在C语言中编码实现。 首先，我们要理解什么是二叉树。二叉树是每个节点最多有两个子节点的树形数据结构，通常分为左子节点和右...
二叉树的基本操作（C语言实现）
03-23
3. **查找节点**：在二叉搜索树（BST，Binary Search Tree）中，查找操作非常高效。从根节点开始，如果待查找值小于当前节点值，向左子树搜索；如果大于当前节点值，向右子树搜索。如果找到与目标值相等的节点，返回...
3.《数据结构与算法(C语言)》练习题库一树与二叉树-ANSWER.zip
最新发布
05-02
《数据结构与算法(C语言)》中的练习题库聚焦在一树与二叉树这一核心主题上，涵盖了数据结构和算法的基础知识。这个压缩包包含了五个文件，分别对应于不同的算法实现和问题解答，旨在帮助学习者深入理解和掌握树与...
实验6 二叉树遍历.doc.zip
02-03
在本实验中，我们将深入探讨二叉树的遍历这一重要的计算机科学概念，特别是与C语言编程相关的实现。二叉树是一种数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。这种数据结构在算法设计、...
实验5 二叉树基本运算.zip
02-03
实验5还可能涉及到二叉搜索树（BST），这是一种特殊类型的二叉树，其中每个节点的左子树只包含键小于该节点的节点，右子树只包含键大于该节点的节点。这使得搜索、插入和删除操作的效率非常高。 此外，实验报告可能...
C语言实现二叉查找树（BST）的基本操作
12-22
我们在上一篇博客中讲解了二叉树，这一次我们来实现二叉树的进阶——二叉查找树（Binary Search Tree），又称二插排序树(Binary Sort Tree)。所以简称为BST。二插查找树的定义如下： 　　1.若左子树不为空，则左子树上所有节点的值均小于它的根节点的值； 　　2.若右子树不为空，则右子树上所有节点的值均大于它的根节点的值； 　　3.左右子树也分别为二叉排序树； 　　二叉排序树的一个重要特点是中序遍历是一个递增序列。示例代码上传至： https://github.com/chenyufeng1991/BinarySearchTree  。 　　（1）节点的构造
二叉查找树的C语言实现——插入，删除，查找
11-21
二叉查找树的C语言实现，实现功能：插入、删除、查找。
二叉搜索树(BST) ----- C语言
Snow Yong
12-11 664
二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。 二叉排序树的查找过程和次优二叉树类似，通常采取二叉链表作为二叉排序树的存储结构。中序遍历二叉排序
LeetCode-173-二叉搜索树的迭代器-C语言
SFFS
05-18 287
/** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */ typedef struct TreeNode Node; typedef struct { ...
leetcode-653. 两数之和 IV - 输入 BST-C语言
SFFS
06-10 246
/** * 算法思想： * 与two sum相同，遍历整棵树，不断将节点值添加到hash表中， * 当访问节点node时，现在hash表中查找target-node->val如果找到直接返回； * 否则将当前节点值添加到hash表中，继续访问其他节点。 * }; */ typedef struct has_node{ int key; struct has_nod...
二叉排序树(BST)的思路及C语言实现
热门推荐
kelvinmao的博客
05-31 1万+
请注意，为了能够更好的理解二叉排序树，我建议各位在看代码时能够设置好断点一步一步跟踪函数的运行过程以及各个变量的变化情况一.动态查找所面临的问题在进行动态查找操作时，如果我们是在一个无序的线性表中进行查找，在插入时可以将其插入表尾，表长加1即可；删除时，可以将待删除元素与表尾元素做个交换，表长减1即可。反正是无序的，当然是怎么高效怎么操作。但如果是有序的呢？回想学习线性表顺序存储时介绍的顺序表的缺点
二叉搜索树（BST数）——C语言实现
qq_27846147的博客
06-28 206
直接上代码 //BST树 #include <stdio.h> #include <stdlib.h> typedef int Elemtype; typedef struct LNode{ struct LNode *Lchild; struct LNode *Rchild; Elemtype data; }LNode; void create(LNode *l) { int key; scanf("%d",&key); l->data = key;
二叉搜索树迭代器
nmslqwq的博客
09-26 180
题目描述 Implement an iterator over a binary search tree (BST). Your iterator will be initialized with the root node of a BST. 实现一个适用于二叉查找树的迭代器，该迭代器通过二叉查找树的根结点来实例化。 Callingnext() will return the next smal...
leetcode173 二叉搜索树迭代器
aikudexue的博客
01-18 283
/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ clas...
c语言二叉树遍历流程图
11-02
很抱歉，根据提供的引用内容，没有提供关于C语言二叉树遍历流程图的信息。但是，我可以为您提供一些关于C语言二叉树遍历的基本知识和方法。 C语言二叉树遍历一般分为三种方式：前序遍历、中序遍历和后序遍历。其中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值