二叉搜索树

最新推荐文章于 2019-10-25 14:00:46 发布
最新推荐文章于 2019-10-25 14:00:46 发布
阅读量265 收藏
点赞数
分类专栏： 数据结构 文章标签： 二叉搜索树 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dangzhangjing97/article/details/79548903
版权

二叉搜索树

又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树

1.若它的左子树不为空，则左子树上所有结点的值都小于根结点的值；
2.若它的右子树不为空，则右子树上所有结点的值都大于根结点的值；
3.它的左右子树也称为二叉搜索树。

二搜索树的插入操作

在向二叉树中插入新元素时，必须先检测这个元素是否在树中已经存在，如果搜索成功。则说明该元素已经存在，则不进行插入，否则将新元素加入到搜索停止的地方

//如果插入的结点在树中有的话，那就直接返回false，不进行插入
    bool Insert(const T& data)
    {
        //先判断树是否为空树，如果是空树直接插入
        if (NULL == _pRoot)
        {
            _pRoot = new Node(data);
            return true;
        }
        //找待插入结点的位置
        else//不是空树
        {
            PNode pCur = _pRoot;
            PNode pParent = NULL;
            while (pCur)
            {
                if (data < pCur->_data)
                {
                    pParent = pCur;//把pCur的位置标记下来，这样方便后面插入结点
                    pCur = pCur->_pLeft;

                }
                else if (data>pCur->_data)
                {
                    pParent = pCur;
                    pCur = pCur->_pRight;
                }
                else
                    return false;
            }
            //插入结点
            pCur = new Node(data);
            if (data < pParent->_data)//如果此节点的数据比待插入数据小，就把它插到左边
                pParent->_pLeft = pCur;
            else
                pParent->_pRight = pCur;//如果此节点的数据比待插入数据小，就把它插到右边
            return true;
        }
    }

二叉搜索树的查找操作
如果此树不是空树的话：

如果根结点的值等于待查找结点的值的话，返回true；
如果根结点的值小于待查找结点的值的话，在根结点的右子树中查找；
如果根结点的值大于待查找结点的值的话，在根结点的左子树中查找；

PNode Find(const T&data)
    {
        PNode pCur = _pRoot;
        while (pCur)
        {
            if (data == pCur->_data)
                return pCur;
            else if (data < pCur->_data)
                pCur = pCur->_pLeft;
            else
                pCur = pCur->_pRight;
        }
        return NULL;
        //在查找节点时，不用判断是空树的情况，因为如果是空树的话就不会进while循环，程序就直接返回了

        //如果是空树，，那就直接返回空指针
        if (NULL == _pRoot)
            return NULL;
        else//不是空树
        {
            PNode pCur = _pRoot;
            while (pCur)
            {
                if (data == pCur->_data)
                    return pCur;
                else if (data < pCur->_data)
                    pCur = pCur->_pLeft;
                else
                    pCur = pCur->_pRight;
            }
            return NULL;
        }
    }

二叉搜索树的删除操作

这里写图片描述

这里写图片描述
第一种情况：待删除结点是叶子结点
这里写图片描述

第二种情况：待删结点只有左子树

这里写图片描述
第三种情况：待删除结点只有右子树

这里写图片描述

第四种情况：待删除结点左右孩子都有
这里写图片描述

由这四种情况可见：第一种情况可以和第二种情况放在一起考虑或者第一种情况和第三种情况放在一起考虑

bool Delete(const T&data)
    {
        //如果是空树，直接返回false
        if (NULL == _pRoot)
            return false;
        //删除结点
        PNode pCur = _pRoot;
        PNode pParent = NULL;
        while (pCur)//找到待删除结点的双亲结点
        {
            if (data == pCur->_data)//根结点的只能等于待删除结点的值
                break;
            else if (data < pCur->_data)//根结点的值大于待删除结点的值(左子树）
            {
                pParent = pCur;
                pCur = pCur->_pLeft;
            }
            else//根结点的值小于待删除结点的值（右子树）
            {
                pParent = pCur;
                pCur = pCur->_pRight;
            }
        }
        //待删除结点只有左子树或者是待删除结点是叶子结点
        if (NULL == pCur->_pRight)
        {
            if (pCur == _pRoot)//如果删除的是根结点
                _pRoot = pCur->_pLeft;//因为此范围内的结点没有右子树，所以可以直接使根结点的左子树成为根结点，
            else
            {
                if (pCur == pParent->_pLeft)//待删除结点是根结点的左子树
                    pParent->_pLeft = pCur->_pLeft;
                else//待删除结点是根结点的右子树，
                    pParent->_pRight = pCur->_pLeft;
            }
        }
        //待删除结点只有右子树或者是待删除结点是叶子结点
        else if (NULL == pCur->_pLeft)
        {
            if (pCur == _pRoot)//如果删除的是根结点
                _pRoot = pCur->_pRight;
            else
            {
                if (pCur == pParent->_pRight)//待删除结点是根结点的右子树
                    pParent->_pRight = pCur->_pRight;
                else//待删除结点是根结点的左子树
                    pParent->_pLeft = pCur->_pRight;
            }
        }
        //待删除结点左右孩子都有
        else
        {
            pParent = pCur;
            PNode pDel = pCur->_pRight;
            //寻找个根结点的右子树中的最小值
            while (pDel->_pLeft)//根结点的右子树的最小值是没有左孩子的
            {
                pParent = pDel;
                pDel = pDel->_pLeft;
            }
            pCur->_data = pDel->_data;
            pCur = pDel;//一定要记得把要删除的结点赋给pCur，因为在程序的最后面，统一删除的是pCur
            if (pDel == pParent->_pLeft)
                pParent->_pLeft = pDel->_pRight;
            else
                pParent->_pRight = pDel->_pRight;
        }
        delete pCur;
        pCur = NULL;
        return true;
    }

循环实现二叉搜索树的插入操作、查找操作、删除操作。

代码：

#include<iostream>
using namespace std;
template <class T>
struct BSTreeNode
{
    BSTreeNode<T> * _pLeft;
    BSTreeNode<T> * _pRight;
    T  _data;
    BSTreeNode(const T& data)
        :_pLeft(NULL)
        , _pRight(NULL)
        , _data(data)
    {}
};
template <class T>
class BSTree
{
    typedef BSTreeNode<T> Node;
    typedef BSTreeNode<T>* PNode;
public:
    BSTree()
        :_pRoot(NULL)
    {}
    //如果插入的结点在树中有的话，那就直接返回false，不进行插入
    bool Insert(const T& data)
    {
        //先判断树是否为空树，如果是空树直接插入
        if (NULL == _pRoot)
        {
            _pRoot = new Node(data);
            return true;
        }
        //找待插入结点的位置
        else//不是空树
        {
            PNode pCur = _pRoot;
            PNode pParent = NULL;
            while (pCur)
            {
                if (data < pCur->_data)
                {
                    pParent = pCur;//把pCur的位置标记下来，这样方便后面插入结点
                    pCur = pCur->_pLeft;

                }
                else if (data>pCur->_data)
                {
                    pParent = pCur;
                    pCur = pCur->_pRight;
                }
                else
                    return false;
            }
            //插入结点
            pCur = new Node(data);
            if (data < pParent->_data)//如果此节点的数据比待插入数据小，就把它插到左边
                pParent->_pLeft = pCur;
            else
                pParent->_pRight = pCur;//如果此节点的数据比待插入数据小，就把它插到右边
            return true;
        }
    }



    PNode Find(const T&data)
    {
        PNode pCur = _pRoot;
        while (pCur)
        {
            if (data == pCur->_data)
                return pCur;
            else if (data < pCur->_data)
                pCur = pCur->_pLeft;
            else
                pCur = pCur->_pRight;
        }
        return NULL;
        //在查找节点时，不用判断是空树的情况，因为如果是空树的话就不会进while循环，程序就直接返回了

        //如果是空树，，那就直接返回空指针
        if (NULL == _pRoot)
            return NULL;
        else//不是空树
        {
            PNode pCur = _pRoot;
            while (pCur)
            {
                if (data == pCur->_data)
                    return pCur;
                else if (data < pCur->_data)
                    pCur = pCur->_pLeft;
                else
                    pCur = pCur->_pRight;
            }
            return NULL;
        }
    }





    bool Delete(const T&data)
    {
        //如果是空树，直接返回false
        if (NULL == _pRoot)
            return false;
        //删除结点
        PNode pCur = _pRoot;
        PNode pParent = NULL;
        while (pCur)//找到待删除结点的双亲结点
        {
            if (data == pCur->_data)//根结点的只能等于待删除结点的值
                break;
            else if (data < pCur->_data)//根结点的值大于待删除结点的值(左子树）
            {
                pParent = pCur;
                pCur = pCur->_pLeft;
            }
            else//根结点的值小于待删除结点的值（右子树）
            {
                pParent = pCur;
                pCur = pCur->_pRight;
            }
        }
        //待删除结点只有左子树或者是待删除结点是叶子结点
        if (NULL == pCur->_pRight)
        {
            if (pCur == _pRoot)//如果删除的是根结点
                _pRoot = pCur->_pLeft;//因为此范围内的结点没有右子树，所以可以直接使根结点的左子树成为根结点，
            else
            {
                if (pCur == pParent->_pLeft)//待删除结点是根结点的左子树
                    pParent->_pLeft = pCur->_pLeft;
                else//待删除结点是根结点的右子树，
                    pParent->_pRight = pCur->_pLeft;
            }
        }
        //待删除结点只有右子树或者是待删除结点是叶子结点
        else if (NULL == pCur->_pLeft)
        {
            if (pCur == _pRoot)//如果删除的是根结点
                _pRoot = pCur->_pRight;
            else
            {
                if (pCur == pParent->_pRight)//待删除结点是根结点的右子树
                    pParent->_pRight = pCur->_pRight;
                else//待删除结点是根结点的左子树
                    pParent->_pLeft = pCur->_pRight;
            }
        }
        //待删除结点左右孩子都有
        else
        {
            pParent = pCur;
            PNode pDel = pCur->_pRight;
            //寻找个根结点的右子树中的最小值
            while (pDel->_pLeft)//根结点的右子树的最小值是没有左孩子的
            {
                pParent = pDel;
                pDel = pDel->_pLeft;
            }
            pCur->_data = pDel->_data;
            pCur = pDel;//一定要记得把要删除的结点赋给pCur，因为在程序的最后面，统一删除的是pCur
            if (pDel == pParent->_pLeft)
                pParent->_pLeft = pDel->_pRight;
            else
                pParent->_pRight = pDel->_pRight;
        }
        delete pCur;
        pCur = NULL;
        return true;
    }
    void InOrder()
    {
        cout << "InOrder:>    ";
        _InOrder(_pRoot);
    }
private:
    void _InOrder(PNode pRoot)
    {
        if (pRoot)
        {
            _InOrder(pRoot->_pLeft);
            cout << pRoot->_data<<"  ";
            _InOrder(pRoot->_pRight);
        }
    }
private:
  PNode _pRoot;
};
void Test()
{
    int a[] = { 1, 4, 6, 7, 8, 9, 2, 5, 3, 0 };
    BSTree<int> Tree;
    int i = 0;
    int sz = sizeof(a) / sizeof(a[0]);
    for (i = 0; i < sz; ++i)
        Tree.Insert(a[i]);//插入操作
    Tree.InOrder();//使用中序遍历输出二叉搜索树，因为中序遍历的结果与二叉搜索树的结果相同
    cout << endl;

    查找节点时，如果找不到那就返回空指针，如果找到了那就返回此值的地址
    cout << Tree.Find(10) << endl;//寻找操作
    cout << Tree.Find(8) << endl;//寻找操作
    cout << Tree.Find(5) << endl;//寻找操作

    //Tree.Delete(0);//删除操作
    //Tree.Delete(5);//删除操作
    //Tree.Delete(4);//删除操作
    //Tree.Delete(6);//删除操作
    //Tree.Delete(8);//删除操作
    //Tree.Delete(7);//删除操作
    Tree.InOrder();
    cout << endl;


}
int main()
{
    Test();
    system("pause");
    return 0;
}

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

递归实现二叉搜索树的插入操作、查找操作、删除操作。

代码：

#include<iostream>
using namespace std;
#include<stdio.h>
template<class T>
struct BinarySearchTreeNode
{
    BinarySearchTreeNode<T>* _pLeft;
    BinarySearchTreeNode<T>* _pRight;
    T _data;
    BinarySearchTreeNode(const T&data)
        : _pLeft(NULL)
        , _pRight(NULL)
        , _data(data)
    {}

};
template<class T>
class BSTree
{

    typedef BinarySearchTreeNode<T> Node;
    typedef BinarySearchTreeNode<T>* PNode;
public:
    BSTree()
        :_pRoot(NULL)
    {}
    bool Insert(const T& data)
    {
         return _Insert(_pRoot, data);
    }
    void InOrder()
    {
        cout << "InOrder:>  ";
        _InOrder(_pRoot);
    }
    //查找某结点，如果查找成功，那就返回此节点的地址，如果不成功，那就返回空指针
    PNode Find(const T&data)
    {
        return _Find(_pRoot, data);
    }
    bool Delete(const T&data)
    {
        return _Delete(_pRoot, data);
    }
private:
    bool _Delete(PNode &pRoot, const T&data)//因为需要修改根结点的指向，所以使用二级指针或者一级指针的引用
    {
        if (NULL == pRoot)
            return false;
        PNode pDel = pRoot;
        /*不管是在左子树还是在右子树，需要删除结点的值都要与树中的结点进行比较，
        所以把这些进行比较的语句统一在一起，可提高效率*/
        if (data > pRoot->_data)
            return _Delete(pRoot->_pRight, data);
        else if (data < pRoot->_data)
            return _Delete(pRoot->_pLeft, data);
        else
        {
            if (NULL == pRoot->_pRight)//右子树为空或左右子树都为空的结点
            {
                pRoot = pRoot->_pLeft;//递归中只关心根，不用判断其他情况，直接删除就好
                delete pDel;
            }
            else if (NULL == pRoot->_pLeft)//左子树为空或左右子树都为空的结点
            {
                pRoot = pRoot->_pRight;
                delete pDel;
            }
            else//左右子树都不为空的结点
            {
                pDel = pRoot->_pRight;
                while (pDel->_pLeft)//找到最小的结点
                    pDel = pDel->_pLeft;
                pRoot->_data = pDel->_data;
                return _Delete(pRoot->_pRight, pDel->_data);
            }
        }
        return false;
    }
private:
    PNode _Find(PNode pRoot, const T&data)
    {
        //如果是空树，那就直接返回空指针
        if (NULL == pRoot)
            return NULL;
        PNode pCur = pRoot;
        while (pCur)
        {
            if (data == pCur->_data)
                return pCur;
            else if (data > pCur->_data)
                return _Find(pCur->_pRight, data);
            return _Find(pCur->_pLeft, data);
        }
         return NULL;
    }
private:
    void _InOrder(PNode pRoot)
    {
        if (pRoot)
        {
            _InOrder(pRoot->_pLeft);
            cout << pRoot->_data << "  ";
            _InOrder(pRoot->_pRight);
        }
    }
private:
    bool _Insert(PNode& pRoot,const T& data)//需要修改根结点的指向，所以需要传二级指针或者也可以传一级指针的引用
    {
        //如果是空树，那就直接插入
        if (NULL == pRoot)//切记是判断，而不是赋值
        {
            pRoot = new Node(data);
            return true;
        }
        else
        {
            if (data < pRoot->_data)
                return _Insert(pRoot->_pLeft,data);
            else
            {
                if (data > pRoot->_data)
                    return _Insert(pRoot->_pRight, data);
                return false;
            }
        }
    }

private:
    PNode _pRoot;
};
void Test()
{
    int a[] = { 1, 4, 6, 7, 8, 9, 2, 5, 3, 0 };
    int i = 0;
    int sz = sizeof(a) / sizeof(a[0]);
    BSTree<int>  Tree;
    for (i = 0; i < sz; ++i)
        Tree.Insert(a[i]);//插入操作
    Tree.InOrder();//使用中序遍历输出插入的结果
    cout << endl;
    cout << Tree.Find(1) << endl;//查找操作
    cout << Tree.Find(3) << endl;//查找操作
    cout << Tree.Find(5) << endl;//查找操作
    cout << Tree.Find(1) << endl;//查找操作
    cout << Tree.Find(10) << endl;//查找操作
    //Tree.Delete(1);//删除操作
    //Tree.Delete(3);//删除操作
    //Tree.Delete(5);//删除操作
    //Tree.Delete(9);//删除操作
    //Tree.Delete(7);//删除操作
    //Tree.Delete(6);//删除操作
    Tree.Delete(4);//删除操作
    Tree.InOrder();
    cout << endl;

}
int main()
{
    Test();
    system("pause");
    return 0;
}

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

dangzhangjing97
关注
专栏目录
二叉查找树
Hi~周星星的博客
08-11 300
二叉查找树 定义：又称为是二叉排序树（Binary Sort Tree）或二叉搜索树。 二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： 　　1) 若左子树不空，则左子树上所有结点的值均小于它的根结点的值； 　　2) 若右子树不空，则右子树上所有结点的值均大于或等于它的根结点...
搜索二叉树
宇哲
10-21 1796
二叉搜索树：它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。二叉搜索树有个特点，最左的是最小的节点，最右的是最大的节点。 当我们把二叉搜索树进行中序遍历的时候，它是进行排序后的结果，所以我们也把二叉搜索树叫做排序二叉树。接下来我们介绍二叉
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
Java 创建二叉搜索树、实现搜索、插入、删除的操作实例 Java 创建二叉搜索树是指通过 Java 语言实现一个二叉搜索树数据结构，该树具有查找、插入、删除等操作的功能。二叉搜索树是一种特殊的二叉树，每个节点的值...
c代码-二叉搜索树的删除操作
07-14
在IT领域，二叉搜索树（Binary Search Tree，简称BST）是一种常见的数据结构，它具有很多优秀的特性，比如快速的查找、插入和删除操作。在实际应用中，我们经常需要对BST进行各种操作，其中删除操作是相对复杂的一个...
树-98. 验证二叉搜索树-PYTHON
01-20
在二叉搜索树（Binary Search Tree，BST）中，每个节点的值必须满足以下规则：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而其右子树中的所有节点的值都大于该节点的值。在给定的题目“树-98. 验证...
Python实现二叉搜索树BST的方法示例
09-18
二叉搜索树（BST，Binary Search Tree），又称为二叉查找树或二叉排序树，是一种特殊的二叉树数据结构，其每个节点的值满足以下条件： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点...
~二叉搜索树~
weixin_33895475的博客
05-02 64
　　搜索树数据结构支持许多动态集合操作，包括SEARCH（查询）、MINIMUM（最小值）、MAXIMUM（最大值）、PREDECESSOR（前驱）、SUCCESSOR（后继）、INSERT（插入）、DELETE（删除）。因此我们使用一棵搜索树既可以作为一个字典又可以作为一个优先队列。 定义 　　对任何结点x，其左子树中的关键字最大不超过x.key，其右子树中的关键字最小不低于x.key。（如...
[互联网面试笔试汇总C/C++-14] 判断一棵二叉树是否是二叉搜索树-微策略
844604778
10-17 167
首先看一下二叉搜索树的定义： 或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉排序树。 原理：一棵二叉搜索树的中续遍历结果是从小到大排序好的，反之亦然。 代码：时间复杂度O(n),空间复杂度O(1) [cpp]view ...
C++_二叉搜索树（二叉排序树，二叉查找树）
hello呀！
08-18 576
二叉搜索树的概念 二叉搜索树，或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉搜索树。 二叉搜索树的相关操作 二叉搜索树的节点定义 template<class T> struct BSTNode { BSTNode(const T...
王道ch4-BiTree-17.判断两棵二叉树是否相似，两棵都是空树，或只有一个结点为相似的，或者两棵树的左子树左子树是相似的，右子树右子树相似
比尔·盖薇的博客
10-25 228
//任务：判断两棵二叉树是否相似，两棵都是空树，或只有一个结点为相似的，或者两棵树的左子树左子树是相似的，右子树右子树相似 bool similar(BiTree& T1, BiTree& T2) { bool l, r; if (T1 == NULL && T2 == NULL) return true; else if (T1 == NULL || ...
二叉搜索树的性质
u010005161的博客
05-28 2219
二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树） 它或者是一棵空树，或者是具有下列性质的二叉树：  1. 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；  2. 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；  3. 它的左、右子树也分别为二叉排序树。 因此，若对它进行中序遍历，则是一颗递增的排好序的序列！ 这一点
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值