二叉搜索树的基本操作

最新推荐文章于 2022-03-31 22:04:18 发布
最新推荐文章于 2022-03-31 22:04:18 发布
阅读量211 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cecilia3333/article/details/80327916
版权

  • 二叉搜索树又称二叉排序树，具有以下性质：

    1.若它的左子树不为空，则左子树上所有节点的值均小于根节点的值；

    2.若它的右子树不为空，则右子树上所有节点的值均大于根节点的值。

如下图所示结构即为一个二叉搜索树：

                

  • 二叉搜索树的基本操作：
#pragma once

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

typedef char SearchNodeType;

typedef struct SearchNode{
    SearchNodeType data;
    struct SearchNode* lchild;
    struct SearchNode* rchild;
}SearchNode;

SearchNode* CreateSearchNode(SearchNodeType value);
void SearchTreeInit(SearchNode** pRoot);
void SearchTreeDestroy(SearchNode** pRoot);
void DestroySearchNode(SearchNode* node);
void SearchTreeInsert(SearchNode** pRoot,SearchNodeType to_insert);
SearchNode* SearchTreeFind(SearchNode* root,SearchNodeType to_find);
void SearchTreePrintChar(SearchNode* root,const char* msg);
void PreOrder(SearchNode* root);
void InOrder(SearchNode* root);
void SearchTreeRemove(SearchNode** pRoot,SearchNodeType to_remove);
void SearchTreeInsert1(SearchNode** pRoot,SearchNodeType to_insert);
SearchNode* SearchTreeFind1(SearchNode* root,SearchNodeType to_find);
void SearchTreeRemove1(SearchNode** pRoot,SearchNodeType to_remove);

1.初始化

void SearchTreeInit(SearchNode** pRoot){
    if(pRoot == NULL)
        return;
    *pRoot = NULL;
    return;
}

2.创建新节点

SearchNode* CreateSearchNode(SearchNodeType value){
    SearchNode* new_node = (SearchNode*)malloc(sizeof(SearchNode));
    new_node->data = value;
    new_node->lchild = NULL;
    new_node->rchild = NULL;
    return new_node;
}

3.销毁节点

void DestroySearchNode(SearchNode* node){
    free(node);
}

4.销毁树

void SearchTreeDestroy(SearchNode** pRoot){
    if(pRoot == NULL)
        return;
    SearchNode* root = *pRoot;
    SearchTreeDestroy(&root->lchild);
    SearchTreeDestroy(&root->rchild);
    DestroySearchNode(root);
    *pRoot = NULL;
    return;
}

5.往二叉搜索树中插入数据

（1）递归版本

void SearchTreeInsert(SearchNode** pRoot,SearchNodeType to_insert){
    if(pRoot == NULL)//非法输入
        return;
    if(*pRoot == NULL){//空树
        SearchNode* new_node = CreateSearchNode(to_insert);
        *pRoot = new_node;
        return;
    }
    //对于树非空的情况，递归插入
    SearchNode* cur = *pRoot;
    if(to_insert < cur->data){//若要插入的数据小于根节点的值，则往左子树中插入
        SearchTreeInsert(&cur->lchild,to_insert);
    }
    else if(to_insert > cur->data){//若要插入的数据大于根节点的值，则往右子树中插入
        SearchTreeInsert(&cur->rchild,to_insert);
    }
    else{//插入的元素与根节点的值相同
        //约定二叉搜索树中所有元素均不重复，返回表示不作任何动作，插入失败
        return;
    }
}

（2）非递归版本

void SearchTreeInsert1(SearchNode** pRoot,SearchNodeType to_insert){
    if(pRoot == NULL)
        return;
    if(*pRoot == NULL){//单独处理空树的情况
        *pRoot = CreateSearchNode(to_insert);
        return;
    }
    //对于非空的树，先找到插入的位置，把要插入元素的父节点记录下来
    SearchNode* cur = *pRoot;//新元素要放置的位置
    SearchNode* pre = NULL;//新元素的父节点
    while(1){
        if(cur == NULL)//找到插入的位置，跳出循环
            break;
        if(to_insert < cur->data){
            pre = cur;
            cur = cur->lchild;
        }
        else if(to_insert > cur->data){
            pre = cur;
            cur = cur->rchild;
        }
        else{//发现相同的元素，按约定：二叉搜索树中的所有元素均不重复，直接插入失败
            return;
        }
    }
    SearchNode* new_node = CreateSearchNode(to_insert);
    if(new_node->data < pre->data){
       pre->lchild = new_node; 
    }
    else{
        pre->rchild = new_node;
    }
    return;
}

6.在二叉搜索树中查找数据

（1）递归版本

SearchNode* SearchTreeFind(SearchNode* root,SearchNodeType to_find){
    if(to_find < root->data){//递归查找左子树
        return SearchTreeFind(root->lchild,to_find);
    }
    else if(to_find > root->data){//递归查找右子树
        return SearchTreeFind(root->rchild,to_find);
    }
    else{
        return root;
    }
}

（2）非递归版本

SearchNode* SearchTreeFind1(SearchNode* root,SearchNodeType to_find){
    SearchNode* cur = root;
    while(1){
        if(cur == NULL)//空树
            return NULL;
        if(to_find < cur->data){
            cur = cur->lchild;
        }
        else if(to_find > cur->data){
            cur = cur->rchild;
        }
        else{
            break;
        }
    }
    return cur;
}

7.打印二叉搜索树

void PreOrder(SearchNode* root){
    if(root == NULL)
        return;
    printf("%c ",root->data);
    PreOrder(root->lchild);
    PreOrder(root->rchild);
    return;
}

void InOrder(SearchNode* root){
    if(root == NULL)
        return;
    InOrder(root->lchild);
    printf("%c ",root->data);
    InOrder(root->rchild);
    return;
}

void SearchTreePrintChar(SearchNode* root,const char* msg){
    printf("[%s]\n",msg);
    printf("先序遍历：");
    PreOrder(root);
    printf("\n");
    printf("中序遍历：");
    InOrder(root);
    printf("\n");
    return;
}

8.删除二叉搜索树中的数据

（1）递归版本

void SearchTreeRemove(SearchNode** pRoot,SearchNodeType to_remove){
    if(pRoot == NULL)//非法输入
        return;
    if(*pRoot == NULL)//空树
        return;
    SearchNode* root = *pRoot;
    if(to_remove <  root->data){//递归查找左子树
        SearchTreeRemove(&root->lchild,to_remove);
        return;
    }
    else if(to_remove >  root->data){//递归查找右子树
        SearchTreeRemove(&root->rchild,to_remove);
        return;
    }
    else{//分情况讨论
        if(root->lchild == NULL && root->rchild == NULL){//要删除的节点无左右子树
            *pRoot = NULL;
            DestroySearchNode(root);
            return;
        }
        else if(root->lchild != NULL && root->rchild == NULL){//要删除的节点只有左子树
            *pRoot = root->lchild;
            DestroySearchNode(root);
            return;
        }
        else if(root->lchild == NULL && root->rchild != NULL){//要删除的节点只有右子树
            *pRoot = root->rchild;
            DestroySearchNode(root);
            return;
        }
        else{//要删除的节点有左右子树
            SearchNode* min = root->rchild;
            while(min->lchild != NULL){//先找到右子树中的最小节点
                min = min->lchild;
            }
            root->data = min->data;//将要删除的节点的值与最小节点的值交换
            SearchTreeRemove(&root->rchild,min->data);//从当前节点的右子树出发，尝试递归的删除刚刚被交换的值
            return;
        }
    }
    return;
}

（2）非递归版本

void SearchTreeRemove1(SearchNode** pRoot,SearchNodeType to_remove){
    if(pRoot == NULL)
        return;
    if(*pRoot == NULL)
        return;
    //先找到要删除的节点
    SearchNode* to_remove_node = *pRoot;
    SearchNode* parent = NULL;
    while(to_remove_node != NULL){
        if(to_remove < to_remove_node->data){
            parent = to_remove_node;
            to_remove_node = to_remove_node->lchild;
        }
        else if(to_remove > to_remove_node->data){
            parent = to_remove_node;
            to_remove_node = to_remove_node->rchild;
        }
        else{//找到了要删除的节点
            break;
        }
    }
    //若找到，分情况：
    if(to_remove_node->lchild == NULL && to_remove_node->rchild == NULL){//左右子树均为空
        if(to_remove_node == *pRoot)//根节点即为要删除的节点
            *pRoot = NULL;
        else{//根节点不是要删除的节点
            if(to_remove_node->data < parent->data)
                parent->lchild = NULL;
            else
                parent->rchild = NULL;
        }
        DestroySearchNode(to_remove_node);
    }
    else if(to_remove_node->lchild != NULL && to_remove_node->rchild == NULL){//只有左子树
         if(to_remove_node == *pRoot)
            *pRoot = to_remove_node->lchild;
        else{
            if(to_remove_node->data < parent->data)
                parent->lchild = to_remove_node->lchild;
            else
                parent->rchild = to_remove_node->lchild;
        }
        DestroySearchNode(to_remove_node);
    }
    else if(to_remove_node->lchild == NULL && to_remove_node->rchild != NULL){//只有右子树
         if(to_remove_node == *pRoot)
            *pRoot = to_remove_node->rchild;
        else{
            if(to_remove_node->data < parent->data)
                parent->lchild = to_remove_node->rchild;
            else
                parent->rchild = to_remove_node->rchild;
        }
        DestroySearchNode(to_remove_node);
    }
    else{//同时有左右子树
        SearchNode* min = to_remove_node->lchild;
        SearchNode* min_parent = to_remove_node;
        while(min->lchild != NULL){
            min_parent = min;
            min = min->lchild;
        }//循环结束，min指向to_remove_node右子树的最小值
        to_remove_node->data = min->data;
        if(min->data < min_parent->data)//min为min_parent的左子树
            min_parent->lchild = min->rchild;
        else//min为min_parent的右子树
            min_parent->rchild = min->rchild;
        DestroySearchNode(min);
        return;
    }
    return;
}

  • 测试函数：
#include"search.h"

#define PRINT_HEAD printf("\n============%s============\n",__FUNCTION__);

void TestInit(){
    PRINT_HEAD;
    SearchNode** pRoot = NULL;
    SearchTreeInit(pRoot);
    printf("pRoot expect NULL,actual %p\n",pRoot);
    return;
}

void TestInsert(){
    PRINT_HEAD;
    SearchNode* root = NULL;
    SearchTreeInit(&root);
    SearchTreeInsert(&root,'a');
    SearchTreeInsert(&root,'d');
    SearchTreeInsert(&root,'b');
    SearchTreeInsert(&root,'e');
    SearchTreeInsert(&root,'c');
    SearchTreeInsert(&root,'f');
    SearchTreePrintChar(root,"插入六个元素");
    return;
}

void TestFind(){
    PRINT_HEAD;
    SearchNode* root = NULL;
    SearchTreeInit(&root);
    SearchTreeInsert(&root,'a');
    SearchTreeInsert(&root,'d');
    SearchTreeInsert(&root,'b');
    SearchTreeInsert(&root,'e');
    SearchTreeInsert(&root,'c');
    SearchTreeInsert(&root,'f');
    SearchNode* ret = SearchTreeFind(root,'c');
    printf("ret expect c,actual %c\n",*ret);
}

void TestRemove(){
    PRINT_HEAD;
    SearchNode* root = NULL;
    SearchTreeInit(&root);
    SearchTreeInsert(&root,'a');
    SearchTreeInsert(&root,'d');
    SearchTreeInsert(&root,'b');
    SearchTreeInsert(&root,'e');
    SearchTreeInsert(&root,'c');
    SearchTreeInsert(&root,'f');
    SearchTreePrintChar(root,"插入六个元素");
    SearchTreeRemove(&root,'c');
    SearchTreePrintChar(root,"删除一个元素");
    return;
}

void TestInsert1(){
    PRINT_HEAD;
    SearchNode* root = NULL;
    SearchTreeInit(&root);
    SearchTreeInsert(&root,'a');
    SearchTreeInsert(&root,'d');
    SearchTreeInsert(&root,'b');
    SearchTreeInsert(&root,'e');
    SearchTreeInsert(&root,'c');
    SearchTreeInsert(&root,'f');
    SearchTreePrintChar(root,"插入六个元素");
    return;
}

void TestFind1(){
    PRINT_HEAD;
    SearchNode* root = NULL;
    SearchTreeInit(&root);
    SearchTreeInsert(&root,'a');
    SearchTreeInsert(&root,'d');
    SearchTreeInsert(&root,'b');
    SearchTreeInsert(&root,'e');
    SearchTreeInsert(&root,'c');
    SearchTreeInsert(&root,'f');
    SearchNode* val = SearchTreeFind(root,'c');
    printf("val expect c,actual %c\n",*val);
}

void TestRemove1(){
    PRINT_HEAD;
    SearchNode* root = NULL;
    SearchTreeInit(&root);
    
    SearchTreeInsert(&root,'d');
    SearchTreeInsert(&root,'b');
    SearchTreeInsert(&root,'f');
    SearchTreeInsert(&root,'a');
    SearchTreeInsert(&root,'c');
    SearchTreeInsert(&root,'e');
    SearchTreeInsert(&root,'g');
    SearchTreePrintChar(root,"插入六个元素");
    SearchTreeRemove(&root,'c');
    SearchTreePrintChar(root,"删除一个元素");
    return;
}

int main(){
    TestInit();
    TestInsert();
    TestFind();
    TestRemove();
    TestInsert1();
    TestFind1();
    TestRemove1();
    return 0;
}

  • 结果演示：


Cecilia3333
关注
专栏目录
PTA天梯赛-二叉搜索树的2层结点统计
q1430186623的博客
11-26 1320
二叉搜索树或者是一棵空树，或者是具有下列性质的二叉树：若它的左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉搜索树。 将一系列数字按给定顺序插入一棵初始为空的二叉搜索树，你的任务是统计结果树中最下面 2 层的结点数。 输入格式：输入在第一行给出一个正整数 N (≤1000)，为插入数字的个数。第二行给出 N 个 [−1000,1000] 区间内的整数。数字间以空格分隔。 输出格式：在一行中输出最下面 2 层
PTA（CCCC决赛模拟）----二叉搜索树的2层结点统计 (25分)
0k-ok
12-05 853
你是我可爱的诱惑，温柔的牵绊，无法割舍的存在.你说青涩最搭初恋，我们有相遇的时间，在风暖月光的地点，海之角也不再遥远.你我之间，看不见的宣言，一直都在，重复过很多年. 二叉搜索树或者是一棵空树，或者是具有下列性质的二叉树：若它的左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉搜索树。 将一系列数字按给定顺序插入一棵初始为空的二叉搜索树，你的任务是统计结果树中最下面 2 层的结点数。 输入格式： 输入
PTA 二叉搜索树的2层结点统计
北边一颗小星星
03-31 1114
二叉搜索树或者是一棵空树，或者是具有下列性质的二叉树：若它的左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉搜索树。 将一系列数字按给定顺序插入一棵初始为空的二叉搜索树，你的任务是统计结果树中最下面 2 层的结点数。 输入格式：输入在第一行给出一个正整数 N (≤1000)，为插入数字的个数。第二行给出 N 个 [−1000,1000] 区间内的整数。数字间以空格分隔。 输出格式：在一行中输出最下面
二叉搜索树的2层结点统计
zhbbbbbb的博客
11-17 1605
题目大意 主要思路 由于二叉搜索树是左子树上所有结点的值均小于或等于它的根结点的值，右子树上所有结点的值均大于它的根结点的值，所以我们每插入一个点就要从根节点dfs找到能存放该点的地方，也就是说如果这个值大于根节点就要往右找，小于等于根节点就要往左找，递归此过程，这样建树并且更新最大深度 AC代码 代码通俗易懂 #include <iostream> #include <algorithm> #include <cstring> #include <cstdio&
二叉搜索树+C++程序+对二叉搜索树的基本操作
最新发布
02-16
二叉搜索树+C++程序+对二叉搜索树的基本操作：包括查找、插入、删除元素。 文件是标准cpp文件，可以在devc++上成功运行，在vs上运行，稍加编辑便可以。 建议用devc，此软件使用方便。
c代码-二叉搜索树的删除操作
07-14
首先，我们需要理解二叉搜索树的基本概念。二叉搜索树的每个节点包含一个键（key）、一个值、以及指向左子树和右子树的指针。每个节点的键都大于其左子树中所有节点的键，小于其右子树中所有节点的键。这样的结构...
二叉搜索树实例练习
09-05
二叉搜索树（Binary Search Tree，BST），是一种特殊的...通过掌握其基本性质和操作，我们可以解决如判断序列是否对应相同二叉搜索树等实际问题。在编程实践中，理解二叉搜索树的内部工作原理和遍历方法是至关重要的。
二叉搜索树_二叉搜索树_源码
10-04
源代码文件很可能是用C语言编写的，用于演示如何实现二叉搜索树的基本操作。C语言是一种底层、高效的编程语言，常用于实现数据结构和算法。 在二叉搜索树的实现中，通常会包含以下关键函数： 1. **创建节点**：`...
Python实现二叉搜索树BST的方法示例
09-18
二叉搜索树（BST，Binary Search Tree），又称为二叉查找树或二叉排序树，是一种特殊的二叉树数据结构，其每个节点的值满足以下条件： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点...
数据结构与算法 ——二叉搜索树
HadwinLing
10-05 220
二叉搜索树（BST）是二叉树的一种特殊表示形式，它满足如下特性： 每个节点中的值必须大于（或等于）存储在其左侧子树中的任何值。 每个节点中的值必须小于（或等于）存储在其右子树中的任何值。 验证二叉搜索树 /** 1. Definition for a binary tree node. 2. public class TreeNode { 3. int val; 4. TreeNode left; 5. TreeNode right; 6. TreeNode(in
数据结构与算法——二叉搜索树
贾维斯的小屋
03-13 5172
一、二叉搜索树 二叉搜索树（BST）满足的性质： 每个节点中的值必须大于（或等于）存储在其左侧子树中的任何值。 每个节点中的值必须小于（或等于）存储在其右子树中的任何值。 一个二叉搜索树的例子如下所示： 图1：二叉搜索树举例 因为二叉树的中序遍历会得到一个递增的序列，因此在二叉搜索树里中序遍历比较常用。 给定一个二叉树，我们要判断它是否是二叉搜索树。二叉搜索树的特征比较明显...
7-9 二叉搜索树的2层结点统计 (25 分)
m0_56312312的博客
03-07 502
1.题目描述： 二叉搜索树或者是一棵空树，或者是具有下列性质的二叉树：若它的左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉搜索树。 将一系列数字按给定顺序插入一棵初始为空的二叉搜索树，你的任务是统计结果树中最下面 2 层的结点数。 输入格式：输入在第一行给出一个正整数 N (≤1000)，为插入数字的个数。第二行给出 N 个 [−1000,1000] 区间内的整数。数字间以空格分隔。 输出格式：在
PAT-A-1115-二叉搜索树最后两层的节点的个数的和
Qingzhx的博客
11-17 129
转自 ：https://blog.csdn.net/weixin_44701217/article/details/105741335 3数组建树，利用v[]存储输入节点，l[],r[],分别存储下标对应的左右子树下标（均指v[]中的下标） #include<iostream> #include<algorithm> using namespace std; const int N = 1010; int n; int l[N], r[N], v[N], idx; int cn
ACM快速输入输出
王跃坤的博客
11-17 1461
package 输入输出; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.io.PrintWriter; import java.io.StreamTokenize...
ElasticSearch 源码分析19 Node && search scroll
郭传志的博客
05-08 272
TransportNodesAction 1.获取请求的nodes节点数组，获取不到就直接return 2.循环nodes数组，然后获取每个node的nodeId 3.根据nodeId创建nodeRequest，然后调用TransportService.sendRequest发送请求 4.回调函数handleResponse来处理请求的响应respon ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ..
PAT1115 Counting Nodes in a BST 二叉搜索树最后两层结点数量
NoobPlayer_llke的博客
07-15 341
二叉搜索树 (BST) 递归定义为具有以下属性的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值 它的左、右子树也分别为二叉搜索树 将一系列数字按顺序插入到一个空的二叉搜索树中，然后，请你计算结果树的最低两层的结点个数。 输入格式 第一行包含整数N，表示插入数字序列包含的数字个数。 第二行包含N个整数，表示插入数字序列。 输出格式 以如下格式，在一行中，输出结果树的最后两层的结点数： n1 +...
L2-3 二叉搜索树的2层结点统计 (25 分)
BIgData_Urumqi的博客
04-06 923
L2-3 二叉搜索树的2层结点统计 (25 分) 二叉搜索树或者是一棵空树，或者是具有下列性质的二叉树：若它的左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉搜索树。 将一系列数字按给定顺序插入一棵初始为空的二叉搜索树，你的任务是统计结果树中最下面 2 层的结点数。 输入格式： 输入在第一行给出一个正整数 N (≤1000)，为插入数字的个数。第二行给出 N 个 [−1000,1000] 区间内的整数。数字
二叉搜索树的插入、查找、删除的递归与非递归实现
小心眼儿猫的博客
05-16 1591
二叉搜索树： 1、要么为一个空树 2、要么不是一个空树 2.1、如果有左子树，对于该树中的每一个节点来说，该节点的左子树上的所有节点都要比该节点小 2.2、如果有右子树，对于该树中的每一个节点来说，该节点的右子树上的所有节点都要比该节点大 下面我们采用递归方法以及非递归方法来实现一下对于二叉搜索树的插入、查找以及删除操作。 1、基本操作：这里的基本操作思路简单，且在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值