0x01数据结构——C语言实现（二叉查找树）

最新推荐文章于 2023-01-24 09:36:21 发布
最新推荐文章于 2023-01-24 09:36:21 发布
阅读量394 收藏 1
点赞数 1
分类专栏： C_C++ Read_Notes Algorithm 文章标签： 二叉查找树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cclethe/article/details/80874307
版权
Read_Notes 同时被 3 个专栏收录
72 篇文章 1 订阅
订阅专栏
C_C++
37 篇文章 2 订阅
订阅专栏
Algorithm
35 篇文章 3 订阅
订阅专栏

0x01数据结构——C语言实现（二叉查找树）

二叉查找树是一种特殊的二叉树，使二叉树成为二叉查找树的性质是：对于树中的每一个节点X，它的左子树中所有关键字值小于X的关键字值，而它的右子树中所有关键字值大于X的关键字值。这意味着，该树所有的元素可以用某种统一的方式排序。

二叉查找树的C语言实现：

b_search_tree.h



#ifndef B_SEARCH_TREE_H
#define B_SEARCH_TREE_H
/*
二叉树的节点用左右孩子表示法来存储。
*/

typedef enum {
    false = 0,
    true
} BOOL;

struct node;
typedef struct node node;
typedef node *Bstree;
typedef node *pos;

//根据先序遍历数组来创建树（先序遍历数组中用'#'来表示空节点）
Bstree create_Bstree_preorder(int v[], int begin, int end);
Bstree create_Bstree(int v[], int *begin, int end);

//将一颗树置空
Bstree make_empty(Bstree T);

//判断树是不是空的
BOOL is_empty(Bstree T);

//为节点p添加孩子节点x
BOOL add_child(node *p, int x);

//先序遍历树
void preorder_traversal(Bstree T);
//以数组形式打印
//数组规定如下：用'#'来表示空节点
void preorder_traversal1(Bstree T);

//中序遍历
void inorder_traversal(Bstree T);

//后序遍历
void postorder_traversal(Bstree T);

//寻找节点x的位置
pos search(int x, Bstree T);

//寻找最大的节点
pos find_max(Bstree T);

//寻找最小的节点
pos find_min(Bstree T);

//插入节点x
Bstree insert_node(int x, Bstree T);

//删除节点x
Bstree delete_node(int x, Bstree T);
pos find_rmin(Bstree T);

//输出二叉树的高度
int Bstree_height(Bstree T);

//输出二叉树总结点数目
int node_sum(Bstree T);

//叶子结点数目
int leaves_sum(Bstree T);

//取出节点p的值
int retrieve_p(pos p);

//以层次方式打印输出
void print_Bstree(Bstree T);
void output(Bstree T, int i);



#endif

b_search_tree.c

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


struct node {
    int val;
    struct node *left;//left child
    struct node *right;//right child
};

struct node;
typedef struct node node;
typedef node *Bstree;
typedef node *pos;

//根据先序遍历数组来创建树（先序遍历数组中用'#'来表示空节点）
Bstree create_Bstree_preorder(int v[], int begin, int end)
{
    return create_Bstree(v, &begin, end);
}

Bstree create_Bstree(int v[], int *begin, int end)
{
    if((*begin)>end || v==NULL) 
        return NULL;
    Bstree T = NULL;
    if(v[*begin]!='#') {
        T=(node *)malloc(sizeof(node));
        T->val = v[*begin];
        (*begin)++;
        if(v[*begin] == '#') {
            T->left = NULL;
            (*begin)++;
            T->right = create_Bstree(v, begin, end);
        } else {
            T->left = create_Bstree(v, begin, end);
            (*begin)++;
            T->right = create_Bstree(v, begin, end);
        }
    }
    return T;
}

//将一颗树置空
Bstree make_empty(Bstree T)
{
    if(T!=NULL) {
        make_empty(T->left);
        make_empty(T->right);
        printf("free node with value %d\n", T->val);
        free(T);
        T = NULL;
    }
    return T;
}

//判断树是不是空的
BOOL is_empty(Bstree T)
{
    return (T == NULL);
}

//为节点p添加孩子节点x
BOOL add_child(node *p, int x)
{
    if(p->left == NULL) {
        p->left = (node*)malloc(sizeof(node));
        p->left->val = x;
        p->left->left = p->left->right = NULL;
        return true;
    } else if(p->right == NULL) {
        p->right = (node*)malloc(sizeof(node));
        p->right->val = x;
        p->right->left = p->right->right = NULL;
        return true;
    } else {
        return false;
    }
}

//先序遍历树
void preorder_traversal(Bstree T)
{
    if(T!=NULL) {
        printf("%d", T->val);
        preorder_traversal(T->left);
        preorder_traversal(T->right);
    }
}

//以先序遍历数组形式打印
//数组规定如下：用'#'来表示空节点
void preorder_traversal1(Bstree T)
{
    if(T!=NULL) {
        printf("%d", T->val);
        if(T->left == NULL) {
            printf("#");
            if(T->right == NULL) {
                printf("#");
            } else {
                preorder_traversal1(T->right);
            }
        } else {
            preorder_traversal1(T->left);
            if(T->right == NULL) {
                printf("#");
            } else {
                preorder_traversal1(T->right);
            }
        }
    }
}

//中序遍历
void inorder_traversal(Bstree T)
{
    if(T!=NULL) {
        inorder_traversal(T->left);
        printf("%d", T->val);
        inorder_traversal(T->right);
    }
}

//后序遍历
void postorder_traversal(Bstree T)
{
    if(T!=NULL) {
        postorder_traversal(T->left);
        postorder_traversal(T->right);
        printf("%d", T->val);
    }
}

//寻找节点x的位置
pos search(int x, Bstree T)
{
    if(T!=NULL) {
        if(T->val == x) {
            return T;
        } else if(x<T->val) {
            return search(x, T->left);
        } else {
            return search(x, T->right);
        }
    } else {
        return NULL;
    }
}

//寻找最大的节点
pos find_max(Bstree T)
{
    if(T!=NULL) {
        while(T->right!=NULL) {
            T = T->right;
        }
    }
    return T;
}

//寻找最小的节点
pos find_min(Bstree T)
{
    if(T != NULL) {
        while(T->left != NULL) {
            T = T->left;
        }
    }
    return T;
}

//插入节点x
Bstree insert_node(int x, Bstree T)
{
    if(T == NULL) {
        T = (node *)malloc(sizeof(node));
        T->val = x;
        T->left = T->right = NULL;
    } else {
        if(x>T->val) {
            T->right = insert_node(x, T->right);
        } else if(x<T->val) {
            T->left = insert_node(x, T->left);
        }
    }
    return T;
}

//删除节点x
Bstree delete_node(int x, Bstree T)
{
    /* 对于删除节点，需要考虑集中情况
     * 如果节点是叶子节点，那么它可以被立即删除
     * 如果节点有一个孩子，则该节点可以在其父节点调整指针跳过该节点后被删除
     * 如果节点有两个孩子，一般的删除策略是用其右子树的最小的数据代替该节点的数据并递归地删除
     * 那个节点。
    */
    if(T!=NULL) {
        if(x<T->val) {
            T->left = delete_node(x,T->left);
        } else if(x>T->val) {
            T->right = delete_node(x,T->right);
        } else {
            if(T->left!=NULL && T->right!=NULL) {
                /*两个孩子的节点*/
                /*寻找右子树最小节点*/

                /*递归方式*/
                pos tmp = find_min(T->right);
                T->val = tmp->val;
                T->right = delete_node(T->val, T->right);

                /*非递归方式*/
//              pos tmp = find_rmin(T);
//              if(tmp == T) {
//                  T->val = tmp->right->val;
//                  tmp->right = tmp->right->right;
//                  free(tmp->right);
//              } else {
//                  T->val = tmp->left->val;
//                  free(tmp->left);
//                  tmp->left = tmp->left->right;
//              }
            } else {
                pos tmp = T;
                if(T->left == NULL) {
                    T = T->right;
                } else if(T->right == NULL) {
                    T = T->left;
                }
                free(tmp);
            }
        }
    }
    return T;
}

pos find_rmin(Bstree T)
{
    /*
     * 寻找数T右子树最小节点
     * 返回其父节点
     */
    if(T != NULL) {
        pos tmp = T;
        T = T->right;
        while(T!=NULL && T->left!=NULL) {
            tmp = T;
            T = T->left;
        }
        return tmp;
    } else {
        return T;
    }
}

//输出二叉树中某个节点的高度
//对任意节点n_i，n_i的深度（depth）为从根到n_i的唯一路径的长。因此，根的深度为0。
//n_i的高（height）是从n_i到一片树叶的最长路径的长。
//因此所有树叶的高度都是0。一棵树的高等于它的根的高。
//一棵树的深度等于它的最深的树叶的深度，该深度总是等于这棵树的高。
int Bstree_height(Bstree T)
{
    if(T!=NULL) {
        int h;
        if(T->left==NULL && T->right==NULL) {
            h=0;
        }else {
            int h1, h2;
            h1 = Bstree_height(T->left)+1;
            h2 = Bstree_height(T->right)+1;
            h = (h1>h2?h1:h2);
        }
        return h;
    } else {
        return -1;
    }
}

//输出二叉树总结点数目
int node_sum(Bstree T)
{

    if(T!=NULL) {
        int sum = 0;
        if(T->left==NULL && T->right==NULL) {
            sum = 1;
        }else {
            int sum1, sum2;
            sum1 = node_sum(T->left);
            sum2 = node_sum(T->right);
            sum = sum1+sum2+1;
        }
        return sum;
    } else {
        return 0;
    }

}

//叶子结点数目
int leaves_sum(Bstree T)
{
    int sum = 0;
    if(T!=NULL) {
        if(T->left==NULL && T->right==NULL) {
            sum = 1;
        }else {
            int sum1, sum2;
            sum1 = leaves_sum(T->left);
            sum2 = leaves_sum(T->right);
            sum = sum1+sum2;
        }
    }
    return sum;
}

//取出节点p的值
int retrieve_p(pos p)
{
    return p->val;
}

//以层次方式打印输出
void print_Bstree(Bstree T)
{
    output(T,0);
}
void output(Bstree T, int i)
{
    if(T != NULL) {
        for(int j = 0; j<i; j++) {
            printf("\t");
        }
        printf("%d\n", T->val);
        i++;
        if(!(T->left == NULL && T->right == NULL)) {
            if(T->left == NULL) {
                printf("\n");
                output(T->right,i);//输出右子树
            } else if(T->right == NULL) {
                output(T->left,i);//输出左子树
                printf("\n");
            } else {
                output(T->left,i);//输出左子树
                output(T->right,i);//输出右子树
            }
        }
    }
}

main.c

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


int main()
{
    int A[13]={6,2,1,'#','#',4,3,'#','#','#',8,'#','#'};
    int h = 0, sum = 0, leaves = 0;
    Bstree T = create_Bstree_preorder(A,0,12);
    int x = 6;
    pos tmp = NULL;

    print_Bstree(T);
    preorder_traversal(T);
    printf("\n");
    inorder_traversal(T);
    printf("\n");
    postorder_traversal(T);
    printf("\n");
    preorder_traversal1(T);
    printf("\n");

    tmp = search(x,T);
    printf("%d\n", retrieve_p(tmp));
    h = Bstree_height(tmp);
    printf("height of the node %d: %d\n", x,h);
    tmp = find_max(T);
    printf("the max node: %d\n", retrieve_p(tmp));  
    tmp = find_min(T);
    printf("the min node: %d\n", retrieve_p(tmp));

    sum = node_sum(T);
    printf("this tree has %d node(s)\n", sum);

    leaves = leaves_sum(T);
    printf("this tree has %d leaves\n", leaves);

    T = insert_node(5, T);
    printf("after insert\n");
    print_Bstree(T);

    printf("after delete\n");
    T = delete_node(2, T);
    print_Bstree(T);

    T = make_empty(T);
    printf("empty? %d\n", is_empty(T));
    return 0;
}
OopspoO
关注
专栏目录
数据结构和算法部分
fabien00的博客
03-15 644
目录1.线性表（1）数组（2）栈（3）队列（4）链表2.树3.哈希表4.集合与映射5.图6.排序（1）冒泡排序选择（3）快速希尔（5）插入（6）归并7.查找8.枚举9.贪心策略（1）钱币找零问题（2）活动选择问题（3）背包问题（4）多机调度问题（5）小船过河问题10.分治策略11.递推与递归12.动态规划13.搜索（1）广度优先搜索（2）深度优先搜索14.图论算法15.字符串算法17.随机算法18.近似算法部分算法代码链接 1.线性表 （说白点就是C语言讲的数组和链表） 线性表的概念： 线性表，全名为线性存
C语言实现二叉查找树（BST）的基本操作
12-22
我们在上一篇博客中讲解了二叉树，这一次我们来实现二叉树的进阶——二叉查找树（Binary Search Tree），又称二插排序树(Binary Sort Tree)。所以简称为BST。二插查找树的定义如下： 　　1.若左子树不为空，则左子树上所有节点的值均小于它的根节点的值； 　　2.若右子树不为空，则右子树上所有节点的值均大于它的根节点的值； 　　3.左右子树也分别为二叉排序树； 　　二叉排序树的一个重要特点是中序遍历是一个递增序列。示例代码上传至： https://github.com/chenyufeng1991/BinarySearchTree  。 　　（1）节点的构造
0x01数据结构——C语言实现（树）
czw
07-01 646
0x01数据结构——C语言实现（树） 树（tree）： 一棵树是一些节点的集合。这个集合可以是空集；若非空，则一棵树由称为根（root）的节点r以及0个或多个非空的（子）树T1T1T_1,T2T2T_2,…,TkTkT_k组成，这些子树种每一颗的根都被来自根r的一条有向边（edge）所连接。每一棵子树的根叫做根r的儿子（child），而r是每一棵子树的根的父亲（parent）。 从节点n1n...
二叉搜索树C语言代码实现
weixin_61819021的博客
05-20 1650
有些题里除了这个概念，不知道的话就蒙圈了。 先序遍历： root——>left——>right 中序遍历： left—— root ——>right 先弄一个只有四个节点的小型二叉树，实际上这种小型二叉树应用不大。 二叉树的真正应用是二叉搜索树，处理海量的数据。 代码很简单，两种遍历的代码也差不多 #include<stdio.h> #include<stdlib.h> typedef struct node{ int data; struct n
二叉排序树c语言,数据结构：二叉查找树(C语言实现)(示例代码)
weixin_34345599的博客
05-19 550
?写在前面关于二叉树的基础知识，请看我的一篇博客:二叉树的链式存储说明：二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：1.若其左子树不空，则左子树上所有结点的值均小于它的根结点的值；2.若其右子树不空，则右子树上所有结点的值均大于它的根结点的值;3.其左、右子树也分别为二叉排序树?二叉查找树的建立(插入)：说明：二叉树的创建是二叉树反复插入节点所构造出来的！若二叉树为空树，则插入元素作为树...
二叉搜索树 c语言,二叉搜索树（C语言实现）
weixin_39823459的博客
05-23 340
数据结构typedef struct TreeNode {int data;//数据struct TreeNode* left;//左孩子struct TreeNode* right;//右孩子}BST, *BinTree;函数声明void Insert(BinTree& BST, int x);//插入元素void Delete(BinTree& BST, int x);//删除...
数据结构——二叉查找树（C语言）
关注校招求职，微信号：job_campus
03-24 2366
定义： 二叉查找树是一棵二叉树，因此可以用链式结构来存储数据。若二叉查找树不为空，则应具有以下性质： 关键字的值唯一若左子树不为空，则子树任何节点关键字值一定小于其根节点的关键字值若右子树不为空，则子树任何节点关键字值一定大于其根节点的关键字值左、右子树任然是二叉查找树 结构 二叉查找树的操作 查找节点： 若二叉查找树为空，则查找失败若该树非空且查找数据x等
二叉查找树(C语言实现 )
Shayabean->MyBlog
05-18 545
二叉查找树:若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉查找树。 在使用递归的时候，假如函数有返回值，记得接收返回值，并且保证函数在每个板块结束后都有return，以防出错。具体见Find、Insert、Delete等函数的实现过程。 Find:通过比较根数据域的值和输入参数的大小递归调用
数据结构（c++）————二叉排序树（实现map操作）
ZCY的博客
09-24 637
本博客是用二叉排序树实现map的查找操作。 一：二叉排序树的性质： （1）若它的左子树非空，则其左子树所有结点的关键字的值均小于其根结点的关键字值。 （2）若它的右子树非空，则其右子树所有结点的关键字的值均大于其根结点关键字的值。 （3）它的左右子树也分别为一棵二叉排序树。 二：二叉树的插入和建立 基本思想：（1）若二叉树为空，则新结点作为二叉排序树的根节点。 （2）若给定结点的关...
数据结构与算法分析复习笔记（持续更新...欢迎指正）
m0_52009789的博客
01-24 7118
数据结构与算法分析 文章目录数据结构与算法分析前言一、数据结构概述数据结构相关基本概念1. 数据2. 数据元素3. 数据项4. 数据对象5. 数据结构6. 程序结构7. 数据类型8. 算法基本结构简介1.从集合到结构体2.映射、函数、算法3.线性结构、树形结构、图形结构算法性能评价1.算法的时间复杂度二、线性结构（ 线性表）三、树形结构四、图形结构 前言 复习408考研数据结构和学习蓝桥杯的笔记，也有相关的离散数学基础内容记录，本笔记以应试为主 持续更新ing 一、数据结构概述 数据结构相关基本概念
团体程序设计天梯赛-练习集 （L2-001 - L2-020）
Obliviate的博客
04-22 5214
团体程序设计天梯赛-练习集 L2-001 紧急救援、L2-002链表去重 、L2-003月饼、L2-004这是二叉搜索树吗、L2-005集合相似度、L2-006树的遍历、L2-007家庭房产、L2-008最长对称子串、L2-009抢红包、L2-010排座位、L2-011玩转二叉树、L2-013红色警报、L2-014列车调度、L2-015互评成绩、L2-016愿天下有情人都是失散多年的兄妹、L2-017人以群分、L2-018多项式A除以B 、L2-019悄悄关注、L2-020 功夫传人
c语言实现二叉搜索树
03-23
1.实现二叉搜索树的基本操作 2.包括建立，查找，删除，显示 3.得到最长路径和最短路径，并能分别计算长度
C语言实现数据结构 二叉排序树
05-08
C语言实现数据结构 二叉排序树C语言实现数据结构 二叉排序树C语言实现数据结构 二叉排序树C语言实现数据结构 二叉排序树
Java面试八股文整理
fwdwqdwq的博客
06-24 584
JRE(Java Runtime Enviroment) 是Java的运行环境。面向Java程序的使用者，而不是开发者。如果你仅下载并安装了JRE，那么你的系统只能运行Java程序。JRE是运行Java程序所必须环境的集合，包含JVM标准实现及 Java核心类库。它包括Java虚拟机、Java平台核心类和支持文件。它不包含开发工具(编译器、调试器等)。JDK(Java Development Kit) 又称J2SDK(Java2 Software Development Kit)，是Java开发工具包，它提
c语言代码实现——查找二叉树
weixin_44125246的博客
05-22 582
主函数main.c #include "search_tree.h" int main(int argc, char const *argv[]) { uint keys[] = {10, 9, 4, 6, 14, 15, 20}; pNode root = create_tree(keys, sizeof(keys)/sizeof(uint)); pre_order_display(root); mid_order_display(root); back_.
二叉查找树 c语言,C语言实现二叉查找树
weixin_39868592的博客
05-20 163
#include#include/**数据结构：二叉查找树，即左孩子*C语言实现*2015-9-13*/typedefstructTreeNode*PtrToNode;typedefPtrToNodeTree;typedefPtrToNodePosition;structTreeNode{intElement;TreeLeft;//节点左孩子TreeRight;/...
二叉查找树--C语言
weixin_52321645的博客
11-10 2950
二叉查找树要求，在树中的任意一个节点，其【左子树】中的每个节点的值，都要【小于】这个节点的值，而【右子树】节点的值都【大于】这个节点的值。 1. 头文件 1.1 include 1.2 定义树是否为空 1.3 树的数据结构 1.4 节点结构体 1.5 树结构体 #include<stdio.h> #include<string.h> #include<stdlib.h> /*树是否为空*/ #define bstree_is_empty(tree)(tr.
二叉查找树的编程与实现 C语言
热门推荐
timerring的博客
07-10 5万+
输入数据的第一行为一个正整数T，表示测试数据的组数，即共 T 组测试数据。每组测试数据的第一行输入正整数 n(5 ≤n ≤20)，第二行输入n个整数，要求依次完成以下工作：1）以这n个整数生成一棵用链式存储结构存储的二叉排序树2）按递增顺序输出该二叉排序树中所有数3）输入一个整数key ，对该二叉排序树进行查找，若在该二叉排序树中存在这个整数key ，则输出find ，否则输出not find；4）输入一个整数key，若该二叉排序树中不存在这个整数key，则将key 插入到该二叉排序树中，使插入后仍为原性质
C语言实现二叉搜索树
最新发布
hou19975418的博客
01-24 276
二叉搜索树的定义如图所示：一棵树，左子树上所有的结点值都比根节点小，右子树上所有的的结点值都比根节点大，同时结点不重复。
C语言版数据结构题集与软考资源大全
"数据结构题集(C语言版)" 是一份以C语言为编程语言的配套数据结构习题集，旨在帮助学习者深入理解和掌握数据结构的相关知识。这份资料可能包含了各种类型的数据结构，如线性表、栈、队列、链表、树、图以及散列表等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值