二叉搜索树

最新推荐文章于 2020-03-17 21:45:35 发布
最新推荐文章于 2020-03-17 21:45:35 发布
阅读量211 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaodu655/article/details/79119534
版权

二叉搜索树：其又叫做二叉排序树，它或是一个空树，或是具有以下性质：
1、若它的左子树不为空，则左子树上所有节点的值都小于根节点的值。
2、若它的右子树不为空，则右子树上所有节点的值都大于根节点的值。
3、它的左右子树也分别为二叉搜索树。

如下图所示的二叉搜索树：
这里写图片描述
给出具体的树的节点的结构如下：（左子树，右子树，key值，value值）

template<class k,class v>
struct BSTreeNode
{
    BSTreeNode(const k&key, const v&value)
    :_pLeft(NULL)
    , _pRight(NULL)
    , _key(key)//要查找的值
    , _value(value)//数组的下标
    {}
    BSTreeNode<k, v>*_pLeft;
    BSTreeNode<k, v>*_pRight;
    k _key;
    v _value;
};

下面来看看二叉搜索树的具体操作：
先来看看查找操作：

这里写图片描述
具体的操作代码为：

    pNode Find(const k&key)//查找函数
    {
        pNode pcur = _pRoot;
        while (pcur)
        {
            if (key == pcur->_key)
            {
                return pcur;
            }
            else if (pcur->_key > key)
            {
                pcur = pcur->_pLeft;
            }
            else
            {
                pcur = pcur->_pRight;
            }
        }
        return NULL;
    }

插入操作：
1.在向二叉搜索树中插入新元素时，先要检测这个元素是否在树中已经存在。若已经存在，则不进行插入，返回false;
2.若需插入的元素小于根节点的key，则继续走到其左子树。
3.若需插入的元素大于根节点的key,则继续走到其右子树。

这里写图片描述
具体的操作代码如下：

bool insert(const k&key, const v&value)//插入
    {
        if (_pRoot == NULL)
        {
            _pRoot = new Node(key, value);
            return true;
        }
        pNode pcur = _pRoot;
        pNode parent = NULL;
        //1.找到待插入的位置
        while (pcur)
        {
            if (key < pcur->_key)
            {
                parent = pcur;
                pcur = pcur->_pLeft;
            }
            else if (key > pcur->_key)
            {
                parent = pcur;
                pcur = pcur->_pRight;
            }
            else
                return false;
        }
        //2.插入新节点
        pcur = new Node(key, value);
        if (key < parent->_key)
        {
            parent->_pLeft = pcur;
        }
        if (key > parent->_key)
        {
            parent->_pRight = pcur;
        }
    }

删除操作：
二叉搜索树的删除操作较为复杂，具体分为四种情况：
1.要删除的节点无左右孩子。
2.要删除的节点只有左孩子。
3.要删除的节点只有右孩子。
4.要删除的节点有左右孩子。

因为情况一可以归结到情况二、三中，所以我们先从情况二开始看。

这里写图片描述

情况三与情况二类似。不展开具体的讨论。

情况四：
这里写图片描述
删除的具体代码实现为：

bool remove(const k&key)//删除
    {
            pNode parent = NULL;
            pNode pcur = _pRoot;
            //1.找到待删除的节点
            while (pcur)
            {
                if (pcur->_key > key)
                {
                    parent = pcur;
                    pcur = pcur->_pLeft;
                }
                else if (pcur->_key < key)
                {
                    parent = pcur;
                    pcur = pcur->_pRight;
                }
                else
                {
                    break;
                }
            }
            if (pcur)
            {
                if (pcur->_pLeft == NULL)//只有右子树
                {
                    if (pcur != _pRoot)
                    {
                        if (parent->_pLeft == pcur)
                            parent->_pLeft = pcur->_pRight;
                        else
                            parent->_pRight = pcur->_pRight;
                    }
                    else
                        _pRoot = pcur->_pRight;
                    delete pcur;
                    pcur = NULL;
                }
                else if (pcur->_pRight == NULL)//只有左子树
                {
                    if (pcur != _pRoot)
                    {
                        if (parent->_pLeft == pcur)
                            parent->_pLeft = pcur->_pLeft;
                        else
                            parent->_pRight = pcur->_pRight;
                    }
                    else
                        _pRoot = pcur->_pLeft;
                    delete pcur;
                    pcur = NULL;
                }
                else      //左右子树存在
                {
                    pNode parent = pcur;
                    pNode pDel = pcur->_pRight;//找到其右子树中序下的第一个节点
                    while (pDel->_pLeft)//找到其左子树
                    {
                        parent = pDel;
                        pDel = pDel->_pLeft;
                    }
                    pcur->_key = pDel->_key;
                    pcur->_value = pDel->_value;
                    if (parent->_pLeft == pDel)
                        parent->_pLeft = pDel->_pLeft;
                    else
                        parent->_pRight = pDel->_pRight;
                    delete pDel;
                    pDel = NULL;
                }
                return true;
            }
            return false;
        }
    //注：若要删除的节点无孩子节点，可以归结到第二三种情况中。

查找最小的数：即为一直在左子树中寻找，具体实现为：

    k MinData()//找寻最左边小的数
    {
        assert(_pRoot);
        pNode pcur = _pRoot;
        while (pcur->_pLeft)
        {
            pcur = pcur->_pLeft;
        }
        return pcur->_key;
    }

查找最大的数：

    k maxData()//找寻最右边大的数
    {
        assert(_pRoot);
        pNode pcur = _pRoot;
        while (pcur->_pRight)
        {
            pcur = pcur->_pRight;
        }
        return pcur->_key;
    }

完整的代码如下：

#include<iostream>
#include<assert.h>
using namespace std;
template<class k,class v>
struct BSTreeNode
{
    BSTreeNode(const k&key, const v&value)
    :_pLeft(NULL)
    , _pRight(NULL)
    , _key(key)//要查找的值
    , _value(value)//数组的下标
    {}
    BSTreeNode<k, v>*_pLeft;
    BSTreeNode<k, v>*_pRight;
    k _key;
    v _value;
};
template<class k,class v>
class BSTree
{
public:
    typedef BSTreeNode<k, v>Node;
    typedef BSTreeNode<k, v>* pNode;
    BSTree()
        :_pRoot(NULL)
    {}
    void _CopyBinaryTee(pNode *pRoot)//创建二叉搜索树
    {
        pRoot = new Node(pRoot->_key, pRoot->_value);
         _CopyBinaryTee(&((*pRoot)->_pLeft));
         _CopyBinaryTee(&((*pRoot)->_pRight));
    }
    BSTree<k, v>& operator = (const BSTree<k, v>& bst)
    {
        if (this != &bt)
        {
            _DestoryBinaryTree(_pRoot);
            _pRoot = _CopyBinaryTree(bt._pRoot);
        }
        return *this;
    }
    void _DestoryBinaryTree(pNode pRoot)//销毁空间
    {
        if (pRoot)
        {
            _DestoryBinaryTree(pRoot->_pLeft);
            _DestoryBinaryTree(pRoot->_pRight);
            delete pRoot;
            pRoot = NULL;
        }
    }
    bool insert(const k&key, const v&value)//插入
    {
        if (_pRoot == NULL)
        {
            _pRoot = new Node(key, value);
            return true;
        }
        pNode pcur = _pRoot;
        pNode parent = NULL;
        //1.找到待插入的位置
        while (pcur)
        {
            if (key < pcur->_key)
            {
                parent = pcur;
                pcur = pcur->_pLeft;
            }
            else if (key > pcur->_key)
            {
                parent = pcur;
                pcur = pcur->_pRight;
            }
            else
                return false;
        }
        //2.插入新节点
        pcur = new Node(key, value);
        if (key < parent->_key)
        {
            parent->_pLeft = pcur;
        }
        if (key > parent->_key)
        {
            parent->_pRight = pcur;
        }
    }
    pNode Find(const k&key)//查找函数
    {
        pNode pcur = _pRoot;
        while (pcur)
        {
            if (key == pcur->_key)
            {
                return pcur;
            }
            else if (pcur->_key > key)
            {
                pcur = pcur->_pLeft;
            }
            else
            {
                pcur = pcur->_pRight;
            }
        }
        return NULL;
    }
    k MinData()//找寻最左边小的数
    {
        assert(_pRoot);
        pNode pcur = _pRoot;
        while (pcur->_pLeft)
        {
            pcur = pcur->_pLeft;
        }
        return pcur->_key;
    }
    k maxData()//找寻最右边大的数
    {
        assert(_pRoot);
        pNode pcur = _pRoot;
        while (pcur->_pRight)
        {
            pcur = pcur->_pRight;
        }
        return pcur->_key;
    }
    void Inorder()
    {
        return _Inorder(_pRoot);
    }
    void _Inorder(pNode pRoot)//中序
    {
        if (pRoot)
        {
            _Inorder(pRoot->_pLeft);
            cout << "<" << pRoot->_key << "," << pRoot->_value << ">" << endl;
            _Inorder(pRoot->_pRight);
        }
    }
    bool remove(const k&key)//删除
    {
            pNode parent = NULL;
            pNode pcur = _pRoot;
            //1.找到待删除的节点
            while (pcur)
            {
                if (pcur->_key > key)
                {
                    parent = pcur;
                    pcur = pcur->_pLeft;
                }
                else if (pcur->_key < key)
                {
                    parent = pcur;
                    pcur = pcur->_pRight;
                }
                else
                {
                    break;
                }
            }
            if (pcur)
            {
                if (pcur->_pLeft == NULL)//只有右子树
                {
                    if (pcur != _pRoot)
                    {
                        if (parent->_pLeft == pcur)
                            parent->_pLeft = pcur->_pRight;
                        else
                            parent->_pRight = pcur->_pRight;
                    }
                    else
                        _pRoot = pcur->_pRight;
                    delete pcur;
                    pcur = NULL;
                }
                else if (pcur->_pRight == NULL)//只有左子树
                {
                    if (pcur != _pRoot)
                    {
                        if (parent->_pLeft == pcur)
                            parent->_pLeft = pcur->_pLeft;
                        else
                            parent->_pRight = pcur->_pRight;
                    }
                    else
                        _pRoot = pcur->_pLeft;
                    delete pcur;
                    pcur = NULL;
                }
                else      //左右子树存在
                {
                    pNode parent = pcur;
                    pNode pDel = pcur->_pRight;//找到其右子树中序下的第一个节点
                    while (pDel->_pLeft)//找到其左子树
                    {
                        parent = pDel;
                        pDel = pDel->_pLeft;
                    }
                    pcur->_key = pDel->_key;
                    pcur->_value = pDel->_value;
                    if (parent->_pLeft == pDel)
                        parent->_pLeft = pDel->_pLeft;
                    else
                        parent->_pRight = pDel->_pRight;
                    delete pDel;
                    pDel = NULL;
                }
                return true;
            }
            return false;
        }
    //注：若要删除的节点无孩子节点，可以归结到第二三种情况中。
    ~BSTree()
    {
        _DestoryBinaryTree(_pRoot);
    }
private:
    pNode _pRoot;
}; 
int main()
{
    int arr[] = {5,3,4,1,7,8,2,6,0,9};
    BSTree<int, int>bst;
    for (int i = 0; i <10; i++)
    {
        bst.insert(arr[i], i);
    }
    bst.Inorder();
    cout << bst.Find(3)->_value << endl;
    cout << endl;
    bst.remove(7);
    bst.Inorder();
    cout << bst.MinData() << endl;
    cout << bst.maxData() << endl;
    system("pause");
    return 0;
}

验证结果为：

这里写图片描述

xiaodu655
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构（六）——二叉树 前序、中序、后序、层次遍历及非递归实现 查找、统计个数、比较、求深度的递归实现
阿修罗道
09-22 33万+
一、基本概念 每个结点最多有两棵子树，左子树和右子树，次序不可以颠倒。 性质： 1、非空二叉树的第n层上至多有2^(n-1)个元素。 2、深度为h的二叉树至多有2^h-1个结点。 满二叉树：所有终端都在同一层次，且非终端结点的度数为2。 在满二叉树中若
二叉树的三中遍历方式
非我非非我的博客
05-30 514
遍历的主要思想：先把数分为主根，主根的左子树，主根的右子树。左子数看成一个整体，进一步分为主根，左子数和右子数。。。。。。①先序遍历       先序遍历的规则：（1）先访问根节点（2）再先序访问左子数（3）再先序访问右子树A-B-D-C-E-F-G解释：先访问根节点A，然后访问A的左子树（包括BD，把分支BD当成一个整体，在先序访问根节点B，然后访问B的左子数D），最后访问A的右子数（包括CEF...
二叉树及其遍历
lslxy1021的博客
10-01 315
二叉树是每个节点最多只有两个分支的树结构，两个分支一般称为左子数和右子树。二叉树的分支具有左右次序，不能颠倒。 二叉树通常作为数据结构应用，应用于高效率的搜索和排序，红黑树、B树等都属于它的变体。红黑树(Red-Black Tree)的实际应用非常广泛，比如Linux内核中的ext3文件系统、Java的HashMap、TreeMap和TreeSet，C++ STL的map。 满足一定条件的二叉...
数据结构 二叉树的定义和性质 C语言
weixin_44174312的博客
03-17 1554
原创作者：小林 1.二叉树的定义： 二叉树是每个结点最多有两个子树的树结构 根节点：一棵树最上面的节点称为根节点。 左右子树：某个节点的左分支叫做左子树，右分支叫做右子树。 左右孩子：某个节点的左、右分支的根节点叫做该节点的左、右孩子。 兄弟节点：具有相同父节点的节点互为兄弟节点。 节点的度：节点拥有的子树数。 叶子节点：没有任何子节点的节点称为叶子节点。 内部节点：非叶子节点称为内部节点...
巧记二叉数的左旋
09-27 540
一，以下的程序是算法导论中的源码，我刚开始看这个左旋的时候看了很久，很是不理解，它到底是怎样旋转的，看图容易理解想要记好程序我感到比较困难。书上有几句是关键点：左旋以x到y的链为轴，使y成为该孩子树新的根结点，x成为y的左孩子，y的左孩子成为x的右孩子；同理右旋以y到x的链为轴，使x为该孩子数的新结点，y成为x的右孩子，x的右孩子成为y的左孩子。左旋和右旋是以指针的形式进行的，具体操作请看到最后：...
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
Java 创建二叉搜索树、实现搜索、插入、删除的操作实例 Java 创建二叉搜索树是指通过 Java 语言实现一个二叉搜索树数据结构，该树具有查找、插入、删除等操作的功能。二叉搜索树是一种特殊的二叉树，每个节点的值...
树-98. 验证二叉搜索树-PYTHON
01-20
在二叉搜索树（Binary Search Tree，BST）中，每个节点的值必须满足以下规则：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而其右子树中的所有节点的值都大于该节点的值。在给定的题目“树-98. 验证...
c代码-二叉搜索树的删除操作
07-14
在IT领域，二叉搜索树（Binary Search Tree，简称BST）是一种常见的数据结构，它具有很多优秀的特性，比如快速的查找、插入和删除操作。在实际应用中，我们经常需要对BST进行各种操作，其中删除操作是相对复杂的一个...
Python实现二叉搜索树BST的方法示例
09-18
二叉搜索树（BST，Binary Search Tree），又称为二叉查找树或二叉排序树，是一种特殊的二叉树数据结构，其每个节点的值满足以下条件： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点...
二叉树的创建、遍历(递归和非递归实现）、交换左右子数、求高度(c++实现)
weixin_34268610的博客
11-18 561
要求：以左右孩子表示法实现链式方式存储的二叉树（lson—rson），以菜单方式设计并完成功能任务：建立并存储树、输出前序遍历结果、输出中序遍历结果、输出后序遍历结果、交换左右子树、统计高度，其中对于中序、后序的遍历运算要求采用非递归的方式实现。 写在前面 二叉树向量存储的优势和弊端 　　二叉树同样有两种存储方式，数组和链式存储，对于数组来说，我们利用二叉树的性质然后利用下标可以方便的找到...
在线测试--二叉树
肉丸不肉
11-13 8556
这次测试！！！！所以要好好总结了sad☀试题1 满分值：5.0分 状态：已答 一棵非空的二叉树的先序遍历序列与后序遍历序列正好相反，则该二叉树一定满足（ ） A．所有的结点均无左孩子 B．所有的结点均无右孩子 C．只有一个叶子结点 D．高度等于其结点数 [我的答案] A．所有的结点均无左孩子 先序：根、左子树先序、右子树先序（其中左右子树又分别满足先序） 后序：
非计算机专业出身对数据结构中的左子树、右子树的理解~
weixin_33859665的博客
07-06 4578
出去面试、被问到计算机数据结构和算法的问题，尴了个尬，听不懂，虽说自己是前端开发，平时算法的问题还是考虑的少点了，自己总结吧~多沉淀点~什么是树？树是一种数据结构，它是由n（n&gt;=1）个有限结点组成一个具有层次关系的集合。附上图片：树具有的特点有：（1）每个结点有零个或多个子结点（2）没有父节点的结点称为根节点（3）每一个非根结点有且只有一个父节点（4）除了根结点外，每个子结点可以分为多个不...
<基础巩固> 二叉搜索树
weixin_34075551的博客
01-15 120
引入：二叉搜索树是这样的一种二叉树：(1)每个元素都有一个关键值，并且没有任意两个元素有相同的关键值(2)根节点的左子树中任意元素的关键值小于根节点的关键值。(3)根节点的右子树中任意元素的关键值大于根节点的关键值。(4)根节点的左右子树也是二叉搜索树。我们这里就用程序来实现这样一颗二叉搜索树。分析：从定义看出，二叉搜索树是一种特殊的二叉树，它给每个元素加上了序的概念，但又不...
B树的基本定义与B树的插入
xiaodu655的博客
03-20 3647
B树： 1.B树的概念： B树是平衡的多叉树，一个节点有多于两个（不能小于）结点的平衡多叉树。 缺点：浪费空间 2.B树的基本性质： &lt;1&gt;.根节点至少有两个孩子 &lt;2&gt;.每个非根节点至少有M/2（上取整）个孩子，至多有M个孩子。 &lt;3&gt;.每个非根节点至少有M/2-1(上取整)个关键字，至多有M-1个关键字。并以升序排列。 &lt;4&gt;.k...
优先级队列
xiaodu655的博客
08-20 971
1.概念： 优先级队列允许用户以任何次序将任何元素堆入容器内，但取出时一定是从优先权最高的（也就是数值最高）的元素开始取，binary max heap正是具有这样的性质，适合作为优先级队列的底层结构。 所谓binary heap就是一种完全二叉树，正操二叉树除了最底层的叶节点之外，是填满的，而最底层的叶节点由左至右又不得有空隙。 那么堆算法在STL中的是：push_heap...
排序（直接排序，快排，希尔排序，归并排序）
xiaodu655的博客
02-01 837
1.直接插入排序：基本算法：将第i个记录插入到前面第i-1个已经排好序的记录中。当插入第i（i>.=1）个元素时，前面的元素已经排好序，此时用array[i]与前面的元素进行比较，找到插入位置之后将array[i]插入，原来的位置上的元素顺序后移。 具体代码实现为： #include using namespace std; void InsertSort(int *array, si
二叉树部分相关练习题
xiaodu655的博客
12-02 582
二叉树：一颗二叉树是节点的的一个有限集合，此集合可为空可由一个根节点及左子树、右子树组成。
堆的创建与应用以及堆排序
xiaodu655的博客
01-22 237
1.堆的概念： 如果有一个关键码的集合K={k0,k1,k2,…,kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki=k2*i+1且ki>=k2*i+2）。（i=0,1,2,…）则称这个堆为最小堆（或最大堆） 堆的特性： 用来存数据——>完全二叉树形式 任意结点满足：1.leftchild=2*i+1; 2.rightchild=2*i+2； 最
二叉搜索树详解及C++实现
"这篇资源提供了一份二叉搜索树的源码实现，包括基本操作如查找最小值、最大值、插入、删除以及不同顺序的遍历。" 二叉搜索树（Binary Search Tree，简称BST），是一种特殊的二叉树，每个节点的左子树只包含比它小...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值