二叉搜索树

最新推荐文章于 2020-03-17 21:45:35 发布
最新推荐文章于 2020-03-17 21:45:35 发布
阅读量213 收藏
点赞数 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
关注
专栏目录
数据结构（六）——二叉树 前序、中序、后序、层次遍历及非递归实现 查找、统计个数、比较、求深度的递归实现
阿修罗道
09-22 33万+
一、基本概念 每个结点最多有两棵子树，左子树和右子树，次序不可以颠倒。 性质： 1、非空二叉树的第n层上至多有2^(n-1)个元素。 2、深度为h的二叉树至多有2^h-1个结点。 满二叉树：所有终端都在同一层次，且非终端结点的度数为2。 在满二叉树中若
二叉树的三中遍历方式
非我非非我的博客
05-30 518
遍历的主要思想：先把数分为主根，主根的左子树，主根的右子树。左子数看成一个整体，进一步分为主根，左子数和右子数。。。。。。①先序遍历       先序遍历的规则：（1）先访问根节点（2）再先序访问左子数（3）再先序访问右子树A-B-D-C-E-F-G解释：先访问根节点A，然后访问A的左子树（包括BD，把分支BD当成一个整体，在先序访问根节点B，然后访问B的左子数D），最后访问A的右子数（包括CEF...
二叉树及其遍历
lslxy1021的博客
10-01 316
二叉树是每个节点最多只有两个分支的树结构，两个分支一般称为左子数和右子树。二叉树的分支具有左右次序，不能颠倒。 二叉树通常作为数据结构应用，应用于高效率的搜索和排序，红黑树、B树等都属于它的变体。红黑树(Red-Black Tree)的实际应用非常广泛，比如Linux内核中的ext3文件系统、Java的HashMap、TreeMap和TreeSet，C++ STL的map。 满足一定条件的二叉...
数据结构 二叉树的定义和性质 C语言
weixin_44174312的博客
03-17 1594
原创作者：小林 1.二叉树的定义： 二叉树是每个结点最多有两个子树的树结构 根节点：一棵树最上面的节点称为根节点。 左右子树：某个节点的左分支叫做左子树，右分支叫做右子树。 左右孩子：某个节点的左、右分支的根节点叫做该节点的左、右孩子。 兄弟节点：具有相同父节点的节点互为兄弟节点。 节点的度：节点拥有的子树数。 叶子节点：没有任何子节点的节点称为叶子节点。 内部节点：非叶子节点称为内部节点...
巧记二叉数的左旋
09-27 543
一，以下的程序是算法导论中的源码，我刚开始看这个左旋的时候看了很久，很是不理解，它到底是怎样旋转的，看图容易理解想要记好程序我感到比较困难。书上有几句是关键点：左旋以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 564
要求：以左右孩子表示法实现链式方式存储的二叉树（lson—rson），以菜单方式设计并完成功能任务：建立并存储树、输出前序遍历结果、输出中序遍历结果、输出后序遍历结果、交换左右子树、统计高度，其中对于中序、后序的遍历运算要求采用非递归的方式实现。 写在前面 二叉树向量存储的优势和弊端 　　二叉树同样有两种存储方式，数组和链式存储，对于数组来说，我们利用二叉树的性质然后利用下标可以方便的找到...
在线测试--二叉树
肉丸不肉
11-13 8567
这次测试！！！！所以要好好总结了sad☀试题1 满分值：5.0分 状态：已答 一棵非空的二叉树的先序遍历序列与后序遍历序列正好相反，则该二叉树一定满足（ ） A．所有的结点均无左孩子 B．所有的结点均无右孩子 C．只有一个叶子结点 D．高度等于其结点数 [我的答案] A．所有的结点均无左孩子 先序：根、左子树先序、右子树先序（其中左右子树又分别满足先序） 后序：
非计算机专业出身对数据结构中的左子树、右子树的理解~
weixin_33859665的博客
07-06 4597
出去面试、被问到计算机数据结构和算法的问题，尴了个尬，听不懂，虽说自己是前端开发，平时算法的问题还是考虑的少点了，自己总结吧~多沉淀点~什么是树？树是一种数据结构，它是由n（n&gt;=1）个有限结点组成一个具有层次关系的集合。附上图片：树具有的特点有：（1）每个结点有零个或多个子结点（2）没有父节点的结点称为根节点（3）每一个非根结点有且只有一个父节点（4）除了根结点外，每个子结点可以分为多个不...
<基础巩固> 二叉搜索树
weixin_34075551的博客
01-15 123
引入：二叉搜索树是这样的一种二叉树：(1)每个元素都有一个关键值，并且没有任意两个元素有相同的关键值(2)根节点的左子树中任意元素的关键值小于根节点的关键值。(3)根节点的右子树中任意元素的关键值大于根节点的关键值。(4)根节点的左右子树也是二叉搜索树。我们这里就用程序来实现这样一颗二叉搜索树。分析：从定义看出，二叉搜索树是一种特殊的二叉树，它给每个元素加上了序的概念，但又不...
B树的基本定义与B树的插入
xiaodu655的博客
03-20 3650
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 977
1.概念： 优先级队列允许用户以任何次序将任何元素堆入容器内，但取出时一定是从优先权最高的（也就是数值最高）的元素开始取，binary max heap正是具有这样的性质，适合作为优先级队列的底层结构。 所谓binary heap就是一种完全二叉树，正操二叉树除了最底层的叶节点之外，是填满的，而最底层的叶节点由左至右又不得有空隙。 那么堆算法在STL中的是：push_heap...
排序（直接排序，快排，希尔排序，归并排序）
xiaodu655的博客
02-01 840
1.直接插入排序：基本算法：将第i个记录插入到前面第i-1个已经排好序的记录中。当插入第i（i>.=1）个元素时，前面的元素已经排好序，此时用array[i]与前面的元素进行比较，找到插入位置之后将array[i]插入，原来的位置上的元素顺序后移。 具体代码实现为： #include using namespace std; void InsertSort(int *array, si
二叉树部分相关练习题
xiaodu655的博客
12-02 591
二叉树：一颗二叉树是节点的的一个有限集合，此集合可为空可由一个根节点及左子树、右子树组成。
栈和队列面试题
xiaodu655的博客
08-16 242
1.实现一个栈，要求实现Push(出栈)、pop(入栈)、min(返回最小值的操作)的时间复杂度为O(1)。 //方法：如果两个栈s1,s2作为辅助栈，每次压入s2都是s1的最小值，元素x入栈时，将x和s2栈顶元素进行比较，如果小于等于s2的栈顶，将x分别push到s1,s2,若x大于s2的栈顶，则将x push到s1中，如果s1.top()==s2.top()，s1和s2都执行pop操作，否则...
二叉搜索树详解及C++实现
"这篇资源提供了一份二叉搜索树的源码实现，包括基本操作如查找最小值、最大值、插入、删除以及不同顺序的遍历。" 二叉搜索树（Binary Search Tree，简称BST），是一种特殊的二叉树，每个节点的左子树只包含比它小...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值