C++实现二叉搜索树基本操作（递归+非递归+应用）

最新推荐文章于 2024-08-07 09:59:39 发布
最新推荐文章于 2024-08-07 09:59:39 发布
阅读量389 收藏 1
点赞数 1
分类专栏： 原创 文章标签： 二叉搜索树 字典树 增删查改 递归+非递归
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stay_the_course/article/details/68951508
版权

基本概念不再多讲，看下面的例子

这里写图片描述

有如图的序列，用插入法建立二叉搜索树并完成相关操作：

代码：

#pragma once


#include <iostream>
#include <assert.h>
#include <string>
using namespace std;

//结点定义
template <class K>
struct SearchBinaryTreeNode
{
    K _key;
    SearchBinaryTreeNode<K>* _left;
    SearchBinaryTreeNode<K>* _right;


    SearchBinaryTreeNode(const K& key)
        :_key(key)
        ,_left(NULL)
        ,_right(NULL)
    {}
};

//搜索二叉树
template <class  K>
class SearchBinaryTree
{
    typedef SearchBinaryTreeNode<K> Node;
public:
    SearchBinaryTree()
        :_root(NULL)
    {}

    //中序遍历
    void InOrder()
    {
        _InOrder(_root);
        cout << endl;
    }

    //插入
    bool Insert(const K& key)
    {
        //1.若为空树则建立一个结点给_root
        if (NULL == _root)
        {
            _root = new Node(key);
            return true;
        }

        //2.不为空，需要找到key的位置，parent记录上一个结点
        //因为搜索二叉树的结点值唯一，所以可以唯一的确认待插入的节点位置
        //cur为空时，cur即为该位置

        Node* parent = _root;
        Node* cur = _root;
        while (cur)
        {
            if (cur->_key < key)
            {
                parent = cur;
                cur = cur->_right;
            }

            else if (cur->_key > key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else
                return false;
        }


        //找到位置以后判断链接关系，当父结点的值大，则链接在父节点左侧
        if (key < parent->_key)
        {
            parent->_left = new Node(key);
            return true;
        }
        //当父结点的值小，则链接在父节点右侧
        else if (key > parent->_key)
        {
            parent->_right = new Node(key);
            return true;
        }
        else return false;
    }

    bool InsertR(const K& key)
    {
        return _InsertR(_root, key);
    }

    //寻找
    Node* Find(const K& key)
    {
        Node* cur = _root;
        while (cur)
        {
            if (cur->_key > key)
            {
                cur = cur->_left;
            }
            else if (cur->_key < key)
            {
                cur = cur->_right;
            }
            else
                return cur;
        }
        return NULL;
    }

    //递归法寻找
    Node* FindR(const K& key)
    {
        return _FindR(_root, key);
    }

    //删除一个节点
    bool Remove(const K& key)
    {

        //结点分为4类：叶子，左为空，右为空，左右均不为空
        //其中叶子节点可划归为左为空或者右为空去处理

        //找到该结点

        Node* parent = NULL;
        Node* cur = _root;
        while (cur)
        {
            if (cur->_key > key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else if (cur->_key < key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else
            {
                Node* del = cur;
                //1.左为空

                if (NULL == cur->_left)
                {
                    if (NULL == parent)
                    {
                        _root = cur->_right;
                    }
                    else
                    {
                        if (parent->_left == cur)
                            parent->_left = cur->_right;
                        else
                            parent->_right = cur->_right;
                    }
                }
                //右为空
                else if (NULL == cur->_right)
                {
                    if (NULL == parent)
                    {
                        _root = cur->_left;
                    }
                    else
                    {
                        if (parent->_left == cur)
                            parent->_left = cur->_left;
                        else
                            parent->_right = cur->_left;
                    }

                }
                //左右均不为空，替换法删除
                //用左子树的最右节点或者右子树的最左结点的值给待删结点
                //然后删除左子树的最右节点或者右子树的最左结点
                else
                {
                    Node* subLeft = cur->_left;
                    Node* subparent = cur;
                    while (subLeft->_right)
                    {
                        subparent = subLeft;
                        subLeft = subLeft->_right;
                    }

                    cur->_key = subLeft->_key;
                    del = subLeft;

                    if (subparent->_right == subLeft)
                        subparent->_right = subLeft->_left;
                    else
                        subparent->_left = subLeft->_left;
                }
                delete del;
                cur = NULL;
                return true;
            }
        }
        return false;
    }

    //递归法删除
    bool RemoveR(const K& key)
    {
        return _RemoveR(_root, key);
    }



protected:
    bool _RemoveR(Node*& root, const K&key)
    {

        if (key < root->_key)
            _RemoveR(root->_left,key);
        else if (key > root->_key)
            _RemoveR(root->_right, key);
        else
        {
            Node* del = root;
            if (root->_left == NULL)
                root = root->_right;
            else if (root->_right == NULL)
                root = root->_left;
            delete del;
            return true;
        }
        return false;
    }

    Node* _FindR(Node* root, const K& key)
    {
        if (key == root->_key)
            return root;
        else if (key < root->_key)
            return _FindR(root->_left, key);
        else
            return _FindR(root->_right, key);
    }


    bool _InsertR(Node*& root, const K& key)
    {
        if (NULL == root)
        {
            root = new Node(key);
            return true;
        }
        else if (key > root->_key)
        {
            return _InsertR(root->_right, key);
        }
        else if (key < root->_key)
        {
            return _InsertR(root->_left, key);
        }
        else
            return false;
    }

    void _InOrder(Node* root)
    {
        if (NULL == root)
        {
            return;
        }
        _InOrder(root->_left);
        cout << root->_key << "  ";
        _InOrder(root->_right);
    }

protected:
    Node* _root;
};



void Test()
{
    int a[] = { 5,3,4,1,7,8,2,6,0,9 };
    SearchBinaryTree<int> t;
    for (size_t i = 0;i < sizeof(a) / sizeof(a[0]);++i)
    {
        t.Insert(a[i]);
    }
    t.Insert(12);
    t.Insert(-1);
    t.InOrder();
    SearchBinaryTreeNode<int>* ret;
    ret = t.Find(8);
    cout << "t.Find(8): " << ret->_key << endl;

    t.Remove(-1);t.InOrder();
    t.Remove(0);t.InOrder();
    t.Remove(1);t.InOrder();
    t.Remove(2);t.InOrder();
    t.Remove(3);t.InOrder();
    t.Remove(4);t.InOrder();
    t.Remove(6);t.InOrder();
    t.Remove(7);t.InOrder();
    t.Remove(8);t.InOrder();
    t.Remove(9);t.InOrder();
    t.Remove(12);t.InOrder();
    t.Remove(5);t.InOrder();//这里执行之后元素全部删除，会输出一个空行

}



    void TestR()
    {
        int a[] = { 5,3,4,1,7,8,2,6,0,9 };
        SearchBinaryTree<int> t;
        for (size_t i = 0;i < sizeof(a) / sizeof(a[0]);++i)
        {
            t.InsertR(a[i]);
        }
        t.InsertR(12);
        t.InsertR(-1);
        t.InOrder();
        SearchBinaryTreeNode<int>* ret;
        ret = t.FindR(8);
        cout << "t.FindR(8): " << ret->_key << endl;

        t.RemoveR(-1);t.InOrder();
        t.RemoveR(0);t.InOrder();
        t.RemoveR(1);t.InOrder();
        t.RemoveR(2);t.InOrder();
        t.RemoveR(3);t.InOrder();
        t.RemoveR(4);t.InOrder();
        t.RemoveR(5);t.InOrder();
        t.RemoveR(6);t.InOrder();
        t.RemoveR(7);t.InOrder();
        t.RemoveR(8);t.InOrder();
        t.RemoveR(9);t.InOrder();
        t.RemoveR(12);t.InOrder();//输出空行
    }

//搜索二叉树的应用：字典实现的基本原理
//key表示主键，value表示其附带信息（即所要查找的内容）
template <class K,class V>
struct BSTreeNode
{
    K _key;
    V _value;
    BSTreeNode<K, V>* _left;
    BSTreeNode<K, V>* _right;

    BSTreeNode(const K& key = K(), const V& value = V())
        :_key(key)
        ,_value(value)
        ,_left(NULL)
        ,_right(NULL)
    {}


};

template <class K,class V>
class BSTree
{
    typedef BSTreeNode<K, V>  Node;

public:
    BSTree()
        :_root(NULL)
    {}

    bool Insert(const K& key, const V& value)
    {
        return _Insert(_root, key, value);
    }

    const Node* Find(const K& key)
    {
        Node* cur = _root;
        while (cur)
        {
            if (key < cur->_key)
                cur = cur->_left;
            else if (key > cur->_key)
                cur = cur->_right;
            else
                return cur;
        }
        return false;

    }
protected:
    bool _Insert(Node*& root, const K& key, const V& value)
    {
        if (NULL == root)
        {
            root = new Node(key, value);
            return true;
        }
        else if (key < root->_key)
        {
            return _Insert(root->_left, key, value);
        }
        else if (key > root->_key)
        {
            return _Insert(root->_right, key, value);
        }
        else return false;
    }



protected:
    Node* _root;
};



void TestKV()
{
    BSTree<string, string> t;

    t.Insert("string", "字符串");
    t.Insert("some", "某些");
    t.Insert("next", "下一个");

    const BSTreeNode<string, string>* ret = t.Find("next");
    cout << ret->_value << endl;//显然结果应该是:下一个
}

运行结果：
这里写图片描述

stay_the_course
关注
专栏目录
C++ 二叉搜索树的基本操作与实现
ZD_free的博客
06-22 267
二叉搜索树 二叉搜索树概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值； 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值； 它的左右子树也分别为二叉搜索树； 二叉搜索树基本操作 二叉搜索树的查找 bool Find(const K& key) //查找 { Node* cur = _root; while (cur) { ..
C++数据结构： 二叉搜索树 （非递归）
earayu的博客
11-17 570
理想情况下BST的插入删除查找花费的时间都是对数级别的，但我们肯定不能依赖“理想情况”。基于下面3个理由： 1. 很多时候输入得序列都是有序或基本有序的 2. 访问一个节点过后很可能再次访问这个节点，或者这个节点附近的节点。 3. 多次删除过后会破坏树的平衡性（可以改变一下删除方式来解决，但是这样的代价比较大）而BST在最差的请况下会退化成一个链表，这显然不是我们想要的结果。所以感觉BST的实
【C++从小白到大牛】搜索二叉树及其递归实现
最新发布
hanwangyyds的博客
08-07 1004
本文主要讲解二叉搜索树的概念、操作以及实现，为后面的的map、set容器实现做准备，因为他们同样也是树形结构。
二叉搜索树 (c++非递归版)
RGBMarco的博客
08-08 326
400多行代码(其实还有好多API没完成),请接受恐惧的代码吧,下面也给出了测试代码BST.h#pragma once #include <stdexcept> #include <stack> template<typename Key, typename Value> class BST { private: class Node { public: No
二叉搜索树 (c++递归版)
RGBMarco的博客
08-07 422
BST.h#pragma once #include <stdexcept> #include <iterator> template<typename Key,typename Value> class BST { private: class Node { public: Node* left = nullptr; Node* right
二叉查找树（搜索树）BST各类操作（c++完整实现）
DouXiang的专栏
03-18 1396
网上一堆，简单总结顺便小小的练习下。 /**************节点结构*****************/ template class BinaryNode { public: BinaryNode(); BinaryNode(const T &value, BinaryNode* l = NULL, BinaryNode* r = NULL); ~BinaryNode()
C++二叉搜索树的递归和非递归实现
qq_53413129的博客
05-09 679
二叉搜索树概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 二叉搜索树的应用 1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。 比如：给一个单词word，判断该单词是否拼写正确，具体方式如下： 以单词集合中的每个单词作为key，构建一棵二叉搜索树 在二叉搜索树中
C++实现二叉搜索树（递归&非递归）
her的博客
06-14 2715
二叉搜索树（Binary Search Tree）的性质： 1、每个节点都有一个作为搜索关键码的key，并且所有节点的key都不相同。 2、左子树上的key值都小于根节点的key值。 3、右子树上的key值都大于根节点的key值。 4、左右子树都是二叉搜索树。 如下图为一颗二叉搜索树 实现： 二叉搜索树的插入： 二叉树的插入是根据要插入节点的key值找一个合适的位置插入节点，如果
二叉搜索树的实现与应用
11-04
本资源是博文【数据结构】二叉搜索树的完整源代码文件，包含K模型搜索树的递归、非递归实现；KV模型搜索树的递归和非递归实现。以及两种模型的测试和应用，主要体现在单词翻译、统计次数、检查单词拼写。可结合以下...
C++实现二叉搜索树（BST），通过控制台能够实现增删改查
12-02
在实际项目中，你可能会遇到更复杂的需求，例如平衡二叉搜索树（AVL或红黑树）以保持高度平衡，或者使用迭代而非递归的方式来优化性能。在提供的压缩包文件"P10_Peifan_Tian"中，可能包含了实现这些功能的源代码示例...
【C++】二叉搜索树
knous
07-27 348
二叉搜索树及模拟实现，后续更新练习题
VC/C++实现二叉搜索树查找算法
12-21
数据结构经典应用，VC/C++,模板类，顺序查找，二分查找，二叉搜索树
【数据结构】——搜索二叉树的插入，查找和删除（递归&非递归）
02-26
本代码是在windows平台下vs2008上编译通过，包含搜索二叉树的插入，查找和删除算法（采用递归和非递归两种方法）。包含全部在平台下的文件，解压可以直接运行。
C++实现二叉搜索树的常用操作
hustyangju的足迹
05-16 1964
实现操作 （1）二叉搜索树的建立 （2）二叉搜索树的插入 （3）二叉搜索树的三种递归遍历（前序、中序和后续） （4）二叉搜索树的三种非递归遍历（前序、中序和后续） （5）二叉搜索树的逐层打印 有时间再实现： （6）二叉搜索树的前驱和后继查找 （7）二叉搜索树的删除 源码分析： #include #include #include using namespace st
数据结构之二叉搜索树的简单实现(C++实现）
qq_41041406的博客
12-23 180
功能 插入：insert() 查找：search() 删除：erase()（用erase命名感觉用意不太符合，但方便以后添加一个删除多个值的重载函数） 清除整个树：clear() 最大值：max() 最小值：min() 前序遍历：PreOrder() 中序遍历：InOrder() 后序遍历：PostOrder() 注：此二叉树允许插入相同的值，且默认将其放在右子树，因此以后会考虑写unique()...
c++实现一个二叉排序树以及树的递归遍历的实现
仗劍走天涯
01-16 484
二叉排序树的理论介绍： https://baike.baidu.com/item/%E4%BA%8C%E5%8F%89%E6%8E%92%E5%BA%8F%E6%A0%91/10905079?fr=aladdin 一棵空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3...
C++---二叉树进阶---二叉搜索树
blue_jun_的博客
10-23 546
C++---搜索二叉树介绍及简单实现，二叉搜索树的应用，性能分析
二叉搜索树(Binary Search Tree)的递归和非递归代码实现(C++)
bestlove12345的博客
06-28 804
二叉搜索树(Binary Search Tree)的递归和非递归代码实现(C++) 二叉搜索树简单介绍 二叉搜索树(Binary Search Tree)是满足： 左子树的根节点比树的根节点小右子树的根节点比树的根节点大  的二叉树。 由于这种数据结构具有很高的查询效率，故多用于需要索引的场合。 二叉搜索树的搜索过程可以理解成类二分查找，因为根节点就等效于一串数
C语言经典算法之二叉树查找（递归实现）
weixin_56154577的博客
02-03 1286
在C语言中，二叉查找树（BST, Binary Search Tree）的查找算法可以通过递归方式实现。
C++实现二叉排序树模板类及其InsertBST和SearchBST功能
本文档主要介绍了如何在C++中使用模板类实现二叉排序树(BiSortTree)的数据结构。首先，我们定义了两个关键数据结构：`BiNode`和`...在实际应用中，二叉排序树因其高效查询和插入操作而被广泛用于搜索、排序等场景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值