二叉搜索树

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

二叉搜索树
当它不为空时，满足如下性质：
当它的左子树不为空时，左子树所有节点都小于根结点的值
当它的右子树不为空时，右子树所有节点都大于根结点的值
它的左右子树分别为二叉搜索树

搜索节点

  • 如果根结点不为空
    • 如果key和节点的值相等,返回
    • 如果key小于节点的值,去左子树查找
    • 如果key大于节点的值,去右子树查找

插入节点

  • 如果根结点为空
    • 直接插入
  • 搜索要插入的位置:
    • 当前节点不为空时
      • 待插入key小于节点值,向左子树走
      • 待插入key大于节点值,向右子树走
      • 如果相等,直接返回
  • 插入节点:
    • 如果key小于当前节点父节点的值
      • 插入到左子树
    • 如果key大于当前节点父节点的值
      • 插入到右子树

删除节点

这里写图片描述

代码：

#include<iostream>
using namespace std;

template<typename T>
struct  BinarySearchNode
{
    BinarySearchNode* _pLeft;
    BinarySearchNode* _pRight;
    T _data;
    BinarySearchNode(const T& data=T())
        :_pLeft(NULL)
        , _pRight(NULL)
        , _data(data)
    {}
};

template<typename T>
class  BinarySerachTree
{
    typedef BinarySearchNode<T> Node;
    typedef Node* pNode;
public:
    BinarySerachTree()
        :_pRoot(NULL)
    {}

    bool Insert(const T& data)
    {
        if (NULL == _pRoot)
        {
            _pRoot = new Node(data);
            return true;
        }
        pNode pCur = _pRoot;
        pNode pParent = pCur;

        while (pCur)
        {
            if (pCur->_data > data)
            {
                pParent = pCur;
                pCur = pCur->_pLeft;
            }
            else if (pCur->_data < data)
            {
                pParent = pCur;
                pCur = pCur->_pRight;
            }
            else
                return false;
        }
        if (pParent->_data < data)
            pParent->_pRight = new Node(data);
        else
            pParent->_pLeft = new Node(data);

        return true;
    }

    pNode Find(const T& data)
    {
        if (NULL == _pRoot)
            return NULL;

        pNode pCur = _pRoot;
        while (pCur)
        {
            if (data == pCur->_data)
                return pCur;
            else if (pCur->_data < data)
                pCur = pCur->_pRight;
            else
                pCUr = pCur->_pLeft;
        }
        return pCur;
    }

    bool Delete(const T& data)
    {
        if (NULL == _pRoot)
            return false;

        if (NULL == _pRoot->_pLeft && NULL == _pRoot->_pRight)//只有一个节点的情况
        {
            if (data == _pRoot->_data)
            {
                delete _pRoot;
                _pRoot = NULL;
                return true;
            }
            else
                return false;
        }

        pNode pCur = _pRoot;
        pNode pDel = NULL;
        pNode pParent = pCur;


        while (pCur)
        {
            if (data == pCur->_data)
            {
                break;
            }
            else if (pCur->_data < data)
            {
                pParent = pCur;
                pCur = pCur->_pRight;
            }
            else
            {
                pParent = pCur;
                pCur = pCur->_pLeft;
            }
        }
        if (NULL == pCur)
            return false;

        if (NULL == pCur->_pLeft)//要删除节点左边为空或者左右子树都为空
        {
            if (pCur != _pRoot)
            {
                if (pParent->_pLeft == pCur)//要删除节点位于上一节点的左边
                {
                    pParent->_pLeft = pCur->_pRight;
                }
                else if (pParent->_pRight == pCur)
                {
                    pParent->_pRight = pCur->_pRight;
                }
            }
            else
                _pRoot = pCur->_pRight;

        }
        else if (NULL == pCur->_pRight)//待删节点的右边为空
        {
            if (pCur != _pRoot)
            {
                if (pParent->_pLeft == pCur)
                {
                    pParent->_pLeft = pCur->_pLeft;
                }
                else if (pParent->_pRight == pCur)
                {
                    pParent->_pRight = pCur->_pLeft;
                }
            }
            else
                _pRoot = pCur->_pLeft;
        }
        else
            //待删节点的左右子树都不为空,
            //找到左子树的最右边节点替换待删节点,或者找到右子树的最左边替换待删节点
            //然后删除找到的节点
        {
            pNode pDel = pCur->_pRight;//右子树的根结点
            pParent = pCur;
            while (pDel->_pLeft)
            {
                pParent = pDel;
                pDel = pDel->_pLeft;
            }
            pCur->_data = pDel->_data;
            pCur = pDel;

            if (pDel == pParent->_pLeft)
                pParent->_pLeft = pDel->_pRight;
            else if (pDel == pParent->_pRight)
                pParent->_pRight = pDel->_pRight;
        }
        delete pCur;
        pCur = NULL;
        return true;
    }
    void InOder()
    {
        if (_pRoot == NULL)
            return;
        cout << "中序遍历:";
        _InOder(_pRoot);
        cout << endl;
    }
private:
    void _InOder(pNode pRoot)
    {
        if (pRoot == NULL)
            return;
        _InOder(pRoot->_pLeft);
        cout << pRoot->_data << " ";
        _InOder(pRoot->_pRight);
    }
private:
    pNode _pRoot;
};

void BinarySearchTreeTest()
{
    BinarySerachTree<int> bs;
    int arr[] = {5,7,8,9,6,3,4,1,0,2};
    for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i)
    {
        bs.Insert(arr[i]);
    }
    bs.InOder();
    //bs.Delete(5);
    bs.Delete(7);
    bs.InOder();
}

递归实现代码:

#pragma once

#include<iostream>
using namespace std;

template<typename T>
struct BinSearchNode
{
    BinSearchNode<T>* _pLeft;
    BinSearchNode<T>* _pRight;
    T _data;
    BinSearchNode(const T& data = T())
        :_pLeft(NULL)
        , _pRight(NULL)
        , _data(data)
    {}
};

template<typename T>
class BinSearchTree
{
    typedef BinSearchNode<T> Node;
    typedef Node* pNode;
public:
    BinSearchTree()
        :_pRoot(NULL)
    {}

    bool Insert(const T& data)
    {
        return _Insert(_pRoot, data);
    }

    pNode Find(const T& data)
    {
        return _Find(_pRoot, data);
    }

    bool Delete(const T& data)
    {
        return _Delete(_pRoot, data);
    }

    void Inder()
    {
        if (NULL == _pRoot)
            return;
        cout << "中序遍历:";
        _Inder(_pRoot);
        cout << endl;
    }
private:

    void _Inder(pNode pRoot)
    {
        if (NULL == pRoot)
            return;
        _Inder(pRoot->_pLeft);
        cout << pRoot->_data << " ";
        _Inder(pRoot->_pRight);
    }

    bool _Delete(pNode& pRoot, const T& data)
    {
        if (NULL == pRoot)
            return false;
        if (NULL == pRoot->_pLeft && NULL == pRoot->_pRight)//只有一个节点
        {
            if (data == pRoot->_data)
            {
                delete pRoot;
                pRoot = NULL;
                return true;
            }
            else
                return false;
        }
        if (data < pRoot->_data)
            return _Delete(pRoot->_pLeft, data);
        else if (data > pRoot->_data)
            return _Delete(pRoot->_pRight,data);
        else
        {
            pNode pDel = pRoot;
            if (NULL == pRoot->_pLeft)//当前子树的左子树为空,让根结点指向根结点的左子树
            {
                pRoot = pRoot->_pRight;
                delete pDel;
                pDel = NULL;
                return true;
            }
            else if (NULL == pRoot->_pRight)
            {
                pRoot = pRoot->_pLeft;
                delete pDel;
                pDel = NULL;
                return true;
            }
            else//左右子树都不为空
            {
                //找到左右子树的最左边节点-背锅侠,替换根结点
                pNode pDel = pRoot;
                pDel = pRoot->_pRight;
                while (pDel->_pLeft)
                    pDel = pDel->_pLeft;

                pRoot->_data = pDel->_data;
                //删除背锅侠
                return _Delete(pRoot->_pRight,pDel->_data);
            }

        }
    }

    pNode _Find(pNode pRoot, const T& data)
    {
        if (NULL == pRoot)
            return NULL;

        if (data == pRoot->_data)
            return pRoot;
        else if (data < pRoot->_data)
            return _Find(pRoot->_pLeft, data);
        else
            return _Find(pRoot->_pRight,data);
    }

    bool _Insert(pNode& pRoot, const T& data)
    {
        if (NULL == pRoot)
        {
            pRoot = new Node(data);
            return true;
        }
        if (data == pRoot->_data)
            return false;
        else if (data < pRoot->_data)
            return _Insert(pRoot->_pLeft, data);
        else
            return _Insert(pRoot->_pRight,data);
    }

private:
    pNode _pRoot;
};


void BinarySearchTreeTest()
{
    BinSearchTree<int> bs;
    //int arr[] = { 5, 7, 8, 9, 6, 3, 4, 1, 0, 2 };
    int arr[] = {5,7,6,9};
    for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i)
    {
        bs.Insert(arr[i]);
    }
    bs.Inder();
    //bs.Delete(5);
    bs.Delete(9);
    bs.Inder();
}
nullcanon
关注
专栏目录
【数据结构】2.树：二叉树、二叉搜索树及其基本实现
深思深练 厚积薄发
05-20 228
一、树概述 1.树定义 树是个结点构成的有限集合。 1）当n=0时，称为空树； 2） 对于任一棵非空树都有一个称为“根（Root）”的结点；其余结点可分为m(m>0)个互不相交的有限集，其中每个集合是原来树的子树。 子树是不相交的；除了根结点外，每个结点有且仅有一个父结点； 一棵N个结点的树有N-1条边。 2.树的一些基本概念 结点的度：结点的子树个数 树的度：树的所有结点中最大的度数 叶结点：度为0的结点 父结点：有子树的结点是其子树的根结点的父结点 子结点：若A结点是B结点的父结点，则称B结点是A
LeetCode 98. 验证二叉搜索树 做题小结
阿拉修
11-29 2292
题目： 给定一个二叉树，判断其是否是一个有效的二叉搜索树。 假设一个二叉搜索树具有如下特征： 节点的左子树只包含小于当前节点的数。 节点的右子树只包含大于当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树。 示例 1: 输入: 2 / \ 1 3 输出: true 示例 2: 输入: 5 / \ 1 4 / \ 3 6 输出: false 解释: 输入为: [5,1,4,null,null,3,6]。 根节点的值为 5 ，但
Leetcode_#530_二叉搜索树的最小绝对值差
松生的博客
05-06 224
原题：#530_二叉搜索树的最小绝对值差 思路： 二叉搜索树的中序遍历是有序的 只需要比较相邻两个节点的值即可 private TreeNode preNode = null; private int minDiff = Integer.MAX_VALUE; public int f (TreeNode root) { helper(root); return min...
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. 节点的右子树中所有节点...
二叉搜索树学习
jiqiren1994的博客
09-12 105
一、简介 如果左子树不为空，则左子树所有结点值都小于根结点的值。 如果右子树不为空，则右子树所有结点值都大于或等于根结点的值。 任意一棵子树也是一棵二叉搜索树。 二、特点 当你需要完成的功能是插入、删除、检索时，二叉搜索树具有极佳的性能 二叉搜索树在排序、检索、数据库管理系统及人工智能等方面广泛应用 二叉搜索树的中序遍历序列是一个递增的序列 三、二叉搜索树的建立 给定一个序列，对序列的每一个元素插入到二叉搜索树： 如果二叉搜索树为空，则该元素即为根结点 如二叉搜索树为非空，如该元素值小于根结点值，插
701. 二叉搜索树中的插入操作
qq_41553240的博客
10-01 91
给定二叉搜索树(BST)的根节点和要插入树中的值，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据保证，新值和原始二叉搜索树中的任意节点值都不同。 注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回任意有效的结果。 例如, 给定二叉搜索树: 4 / \ ...
二叉搜索树操作详解
冷山不生云
02-28 371
二叉搜索树(二叉排序树）是一种搜索结构，它通常具有一下特点： 若他的左子树不为空，则左子树上的所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 中序遍历的结果是升序序列 下面，我讲一下二叉搜索树的基本操作方法 查找 若根节点不为空： 如果根节点key == 目标key,返回true 如果根节点key &gt;...
二叉搜索树的性质
fly away!
07-04 531
期末爆炸，昨晚作业来写一道题~~~ 题目描述 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。 public class Solution {     public boolean VerifySquenceOfBST(int [] sequence) {        
二叉搜索树的基本操作
Tianzez的博客
03-14 371
二叉搜索树（Binary Search Tree）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉搜索树树。节点设置：typedef int DataType;typedef struct BSTreeNode { struct BSTre
二叉搜索树详解及C++实现
"这篇资源提供了一份二叉搜索树的源码实现，包括基本操作如查找最小值、最大值、插入、删除以及不同顺序的遍历。" 二叉搜索树（Binary Search Tree，简称BST），是一种特殊的二叉树，每个节点的左子树只包含比它小...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值