二叉搜索树

最新推荐文章于 2022-07-13 00:21:36 发布
最新推荐文章于 2022-07-13 00:21:36 发布
阅读量631 收藏 3
点赞数
分类专栏： 数据结构 文章标签： 搜索二叉树 插入 删除 查找
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/f2016913/article/details/68941083
版权
一：二叉搜索树的性质：
1：每个节点都有一个作为搜索的关键码（key）,所有节点的关键码互不相同；
2：左子树所有节点的关键码（key）都小于右子树的关键码(key)
3 : 左子树所有节点的关键码（key）都小于右子树的关键码(key)

4：左右字子树都是二叉搜索树


二：二叉树的插入：
分三步：
1：空树的情况，直接把节点插入到根节点
2：不为空，比较插入值的关键码与根节点的关键码，确定插入的位置
3：插入后结果任然为一颗二叉搜索树
如：我们希望插入10；parent和cur都是从根节点开始，10比5大，走右子树，比7大继续右子树，每次走的一步parent都置为当前值（cur），cur继续向下走，一直到9。最后把值插入到9的后面。
插入后仍然为二叉搜索树 


bool Insert(const K&key)
    {
        //为空
        if (_root == NULL)
        {
            _root = new Node(key);
            return true;
        }
        //不为空
        Node*cur = _root;
        Node *parent = NULL;
        while (cur)
        {
            if (cur->_key < key)//右边
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_key>key)//左边
            {
                parent = cur;
                cur = cur->_left;
            }
            else
            {
                return false;//不存在
            }
        }
        //key值存在
        Node*tmp = new Node(key);
        if (parent->_key < key)//右边
        {
            parent->_right = tmp;;
        }
        else //左边
        {
            parent->_left = tmp;   
        }   
        return false;//值相等
    }
三：二叉树的查找
1：查找的值与根节点的值比较，从根开始，查找的值比根的值小走左子树，比根的值大走右子树，直到遍历完这个二叉搜索树，结果有两种找到，找不到；
//查找 
 bool Find(const K&key)
    {
        Node*cur = _root;
        while (cur)
        {
            if (cur->_key < key)//右边
            {
                cur = cur->_right;
            }
            else if (cur->_key >key)//左边
            {
                cur = cur->_left;
            }
            else
            {
                cout << "找到了" <<cur->_key<< endl;
                return true;
            }
        }
        return false;//没找到
    }


四：二叉树的删除：
删除的算法我们可以分为4种情况：
1：删除叶子节点
   
      Node*cur = _root;
        Node*parent = NULL;    
      //叶子节点直接删除
                if (cur->_left == NULL)
                {
                    if (parent &&cur == parent->_left)//左为空
                    {
                        parent->_left = NULL;

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

2：删除非叶子点

替换法删除找最右孩子的左子树，或者是最左孩子的右子树，，先交换要删除的节点与其右孩子交换，然后把要删除的节点右孩子赋给父亲的右孩子。最后删除当前结点。

3:  删除根节点；


 
4：删除所有节点；
删除算法： 
bool Remove(const K&key)
    {
        //为空
        if (_root == NULL)
        {
            return false;
        }
        //不为空  
        Node*cur = _root;
        Node*parent = NULL;
        while (cur)
        {
            if (cur->_key < key)//右边
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_key>key)//左边
            {
                parent = cur;
                cur = cur->_left;
            }
            //要删除的节点就是当前节点
            else
            {
                //叶子节点直接删除
                if (cur->_left == NULL)
                {
                    if (parent &&cur == parent->_left)//左为空
                    {
                        parent->_left = NULL;

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

                //只有一个孩子节点
                else if (cur->_left == NULL || cur->_right == NULL)
                {
                    if (cur->_left != NULL)//只有左孩子
                    {
                        if (parent == NULL)
                        {
                            _root = cur->_left;
                        }
                        else if (parent->_left = cur)//左子树
                        {
                            parent->_left = cur->_left;
                        }
                        else
                        {
                            parent->_right = cur->_left;
                        }
                        delete cur;
                    }
                    else if (cur->_right != NULL)//只有右孩子
                    {
                        if (parent == NULL)
                        {
                            _root = cur->_right;
                        }
                        else if (parent->_right == cur)
                        {
                            parent->_left = cur->_right;
                        }
                        else
                        {
                            parent->_right = cur->_right;
                        }
                        delete cur;
                    }
                }

                //有两个孩子(替换法删除)找最右孩子的左子树
                else
                {
                    Node* subRight = cur->_right;
                    Node* subParent = cur;
                    Node*del = NULL;
                    while (subRight->_left)
                    {
                        subParent = subRight;
                        subRight = subRight->_left;
                    }

                    cur->_key = subRight->_key;
                    if (subParent->_right == subRight)
                        subParent->_right = subRight->_right;
                    else
                        subParent->_left = subRight->_left;
                    delete subRight;
                }
                return true;
            }
        }
        return false;
    }//没有找到删除值

完整代码：

.h文件
#pragma once
#include<iostream>
using namespace std;
template<class K>
struct BinarySerachTreeNode
{
    K _key;
    BinarySerachTreeNode<K> *_left;
    BinarySerachTreeNode<K> *_right;

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

template < class K>
class BinarySerachTree
{
    typedef BinarySerachTreeNode<K> Node;
public:
    BinarySerachTree()
        :_root(NULL)
    {}
    //插入
    bool Insert(const K&key)
    {
        //为空
        if (_root == NULL)
        {
            _root = new Node(key);
            return true;
        }
        //不为空
        Node*cur = _root;
        Node *parent = NULL;
        while (cur)
        {
            if (cur->_key < key)//右边
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_key>key)//左边
            {
                parent = cur;
                cur = cur->_left;
            }
            else
            {
                return false;//不存在
            }
        }
        //key值存在
        Node*tmp = new Node(key);
        if (parent->_key < key)//右边
        {
            parent->_right = tmp;;

        }
        else //左边
        {
            parent->_left = tmp;   
        }   
        return true;
    }
    //查找
    bool Find(const K&key)
    {
        Node*cur = _root;
        while (cur)
        {
            if (cur->_key < key)//右边
            {
                cur = cur->_right;
            }
            else if (cur->_key >key)//左边
            {
                cur = cur->_left;
            }
            else
            {
                cout << "找到了" <<cur->_key<< endl;
                return true;
            }
        }
        return false;//没找到
    }
    //删除
    bool Remove(const K&key)
    {
        //为空
        if (_root == NULL)
        {
            return false;
        }
        //不为空
        Node*cur = _root;
        Node*parent = NULL;
        while (cur)
        {
            if (cur->_key < key)//右边
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_key>key)//左边
            {
                parent = cur;
                cur = cur->_left;
            }
            //要删除的节点就是当前节点
            else
            {
                //叶子节点直接删除
                if (cur->_left == NULL)
                {
                    if (parent &&cur == parent->_left)//左为空
                    {
                        parent->_left = NULL;

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

                //只有一个孩子节点
                else if (cur->_left == NULL || cur->_right == NULL)
                {
                    if (cur->_left != NULL)//只有左孩子
                    {
                        if (parent == NULL)
                        {
                            _root = cur->_left;
                        }
                        else if (parent->_left = cur)//左子树
                        {
                            parent->_left = cur->_left;
                        }
                        else
                        {
                            parent->_right = cur->_left;
                        }
                        delete cur;
                    }
                    else if (cur->_right != NULL)//只有右孩子
                    {
                        if (parent == NULL)
                        {
                            _root = cur->_right;
                        }
                        else if (parent->_right == cur)
                        {
                            parent->_left = cur->_right;
                        }
                        else
                        {
                            parent->_right = cur->_right;
                        }
                        delete cur;
                    }
                }

                //有两个孩子(替换法删除)找最右孩子的左子树
                else
                {
                    Node* subRight = cur->_right;
                    Node* subParent = cur;
                    Node*del = NULL;
                    while (subRight->_left)
                    {
                        subParent = subRight;
                        subRight = subRight->_left;
                    }

                    cur->_key = subRight->_key;
                    if (subParent->_right == subRight)
                        subParent->_right = subRight->_right;
                    else
                        subParent->_left = subRight->_left;
                    delete subRight;
                }
                return true;
            }
        }
        return false;
    }//没有找到删除值
    //中序
    void InOrder()
    {
        _InOrder(_root);
        cout << endl;
    }
protected:
    void _InOrder(Node*root)
    {
        Node*cur = root;
        if (cur == NULL)
        {
            return ;
        }
        _InOrder(cur->_left);
        cout << cur->_key << " ";
        _InOrder(cur->_right);
    }
protected:
    Node* _root;
};


void TestBinarySearchTree()
{
    BinarySerachTree<int> b;
    int a[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 };
    for (int i = 0; i <sizeof(a) / sizeof(a[0]);i++)
    {
        b.Insert(a[i]);
    }
    b.InOrder();
    b.Find(3);

    b.Remove(9);
    b.InOrder();

    b.Remove(0);
    b.InOrder();

    b.Remove(2);
    b.InOrder();

    b.Remove(7);
    b.InOrder();

    b.Remove(5);
    b.InOrder();

    b.Remove(1);
    b.Remove(3);
    b.Remove(4);
    b.Remove(6);
    b.Remove(8);
    b.InOrder();
}


f2016913
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉搜索树的性质
fly away!
07-04 518
期末爆炸，昨晚作业来写一道题~~~ 题目描述 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。 public class Solution {     public boolean VerifySquenceOfBST(int [] sequence) {        
算法笔记---二叉查找树的性质
、思考致富的博客
04-13 171
题目描述 给出N个正整数来作为一棵二叉排序树的结点插入顺序，问：这串序列是否是该二叉排序树的先序序列或是该二叉排序树的镜像树的先序序列。所谓镜像树是指交换二叉树的所有结点的左右子树而形成的树（也即左子树所有结点数据域大于或等于根结点，而根结点数据域小于右子树所有结点的数据域）。如果是镜像树，则输出YES，并输出对应的树的后序序列；否则，输出NO。 输入样例1 7 8 6 5 7 10 8 11 输...
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. 节点的右子树中所有节点...
二叉搜索树基本性质
qq_43434328的博客
01-28 666
二叉搜素树满足三个性质 1.任意节点的左子树若不为空，那么左子树上的所有节点均小于等于该节点的值 2.任意节点的右子树若不为空，那么右子树上的所有节点均大于等于该节点的值 3.任意节点的左右子树也均为二叉搜素树 ...
二叉搜索树（特性篇）
c630843901的博客
07-06 308
二叉搜索树并不算复杂，但我觉得它可以算是数据结构领域的半壁江山，直接基于 BST 的数据结构有 AVL 树，红黑树等等，拥有了自平衡性质，可以提供 logN 级别的增删查改效率；还有 B+ 树，线段树等结构都是基于 BST 的思想来设计的。从做算法题的角度来看 BST，除了它的定义，还有一个重要的性质：BST 的中序遍历结果是有序的（升序）。也就是说，如果输入一棵 BST，以下代码可以将 BST 中每个节点的值升序打印出来： 寻找第 K 小的元素 力扣第 230 题「 二叉搜索树中第 K 小的元素」 ，一个
二叉查找树的性质和用法
m0_51711089的博客
07-13 319
二叉查找树的定义：左子树都要小于或者等于根节点的数据域，右子树都要大于根节点的数据与。1.二叉查找树的寻找操作：该根节点的数据域大于x值，说明该结点的数据域大了，就该往左子树寻找进行递归。该根结点的数据域小于x值，说明该结点的数据域小了，就该往右子树寻找进行递归。root等于NULL的话说明寻找失败。代码: 一般的二叉树寻找，因为子树的数据域是无序的，没有选择，而二叉寻找树可以有选择地递归左右子树，且二叉寻找树的数据域大小排序是root->lchild->data < root->data ..
二叉搜索树的性质及Python实现（数据结构与算法4）
luluzsa的博客
03-02 543
1.二叉搜索树（BST）性质：小于父节点的键都在左子树中，大于父节点的键都在右子树中。 我们采用“节点与引用”表示法实现二叉搜索树，由于必须创建并处理一颗空的二叉搜索树，所以我们将使用两个类，一个为BinarySearchTree,另一个为TreeNode，具体实现代码如下。 class BinarySearchTree: def __init__(self): self.root=None self.size=0 def length(se
二叉搜索树的性质与实现
zhanglifu081022的专栏
11-14 640
二叉搜索树是一种特殊的二叉树，对于其中的任意一个节点z，如果其存在左子树，则其左子树存储的关键字值最大不超过z所存储的关键字值；如果其存在右子树，则其右子树存储的关键字值最小不小于z所存储的关键字值。对于相同的关键字集合，可以有不同的二叉搜索数构型。如下图所示都是二叉搜索树： 二叉搜索数拥有许多特殊的性质，下面就以其性质与一些属性为主线，实现一个基本的二叉搜索树。首先，定义一个头
二叉搜索树性质与实现
飞扬的青春的专栏
08-27 1007
一、概念        搜索树
二叉树的性质及二叉查找树的实现
全村最靓的仔
08-31 397
二叉树的性质 树中的结点数等于数的边数加1，也等于所有的度数之和加1(此性质适合所有的树) 在二叉树的第i层上最多有2i2^i2i个结点，其中i从第0层开始 高度为h的二叉树至多有2h+1−12^{h+1}-12h+1−1个结点 对于任意一棵二叉树T，如果其终端节点数为n0，度为2的结点数为n2，则n0 = n2 + 1 (可以使用性质1来推导，n = n0 + n2 + n1 , n = ...
二叉树的性质以及二叉查找树的基本操作
jayxu无捷之径的博客
08-06 1649
1、基本概念 树（Tree）是n（n≥0）个结点的有限集。在任意一棵非空树中：（1）有且仅有一个特定的被称为根（Root）的结点；（2）当n>1时，其余结点可分为m（m>0）个互不相交的有限集T1，T2，…，Tm，其中每一个集合本身又是一棵树，并且称为根的子树（SubTree）。 度：结点拥有的子树数称为结点的度（Degree）。度为0的结点称为叶子（Leaf）或终端结点。度不为0的结点称
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值