搜索二叉树

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

搜索二叉树的性质

    1. 每个节点都有一个作为搜索依据的关键码（key），所有节点的关       键码互不相同。
    2. 左子树上所有节点的关键码（key）都小于根节点的关键码（key）。
    3. 右子树上所有节点的关键码（key）都大于根节点的关键码（key）。
    4. 左右子树都是二叉搜索树。

例如：
这里写图片描述
第二棵树中，左边的8比根节点5大，右边的4比根节点5小.不满足搜索二叉树的性质。

搜索二叉树的插入

在插入一个数后，依然满足搜索二叉树。

插入分为：
1、为空树，就直接插入。
2、从根节点依次比较，比根节点小，往左树找，比根节点大，往右树找。找到后进行插入。
3、有了这个数就直接返回，不进行插入。
非递归：

bool Insert(const K& key)//非递归插入
    {
        if (_root == NULL)//为空树，直接插入
        {
            _root = new Node(key);
            return true;
        }
        Node* cur = _root;
        Node* parent = NULL;
        while (cur)
        {
            parent = cur;
            if (key > cur->_key)//左树进行找
            {
                cur = cur->_right;
            }
            else if (key < cur->_key)//右树进行找
            {
                cur = cur->_left;
            }
            else//没找到直接返回
            {
                return false;
            }
        }
        if (key < parent->_key)
        {
            parent->_left = new Node(key);
        }
        else
        {
            parent->_right = new Node(key);
        }
        return true;
    }

递归：

bool _InsertR(Node*& cur, size_t key)//递归插入
    {
        if (cur == NULL)
        {
            cur = new Node(key);
            return true;
        }

        if (key < cur->_key)
        {
            _InsertR(cur->_left,key);
        }
        else if(key > cur->_key)
        {
            _InsertR(cur->_right,key);
        }
        else
        {
            return false;
        }
    }

搜索二叉树的查找

查找分为：
1、空树，直接返回false。
2、与根节点比较，比根节点小，左子树找，比根节点大，右子树找。找到后返回true。
3、没找到，返回false。
非递归：

bool Find(const K& key)//非递归插入
    {
        if (_root == NULL)//空树
            return false;
        Node* cur = _root;
        while (cur)
        {
            if (key < cur->_key)//左树找
            {
                cur = cur->_left;
            }
            else if (key > cur->_key)//右树找
            {
                cur = cur->_right;
            }
            else//找到
            {
                return true;
            }
        }
        return false;
    }

递归：

bool _FindR(Node*& cur, size_t key)//递归查找
    {
        if (cur == NULL)
            return false;
        if (key < cur->_key)
        {
            _FindR(cur->_left, key);
        }
        else if (key > cur->_key)
        {
            _FindR(cur->_right, key);
        }
        else
        {
            return true;
        }
        return false;
    }

搜索二叉树的删除

在删除一个数后，依然满足搜索二叉树。

删除分为：
1、空树，直接返回。
2、先找这个数，找不到返回。
3、找到后，左子树为空。
4、找到后，右子树为空。
5、找到后，左右都不为空。
大致情况为：

这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述

非递归：

bool Remove(const K& key)
    {
        if (_root == NULL)//空树，删除不了 ，返回false
            return false;
        Node* cur = _root;
        Node* parent = NULL;
        Node* del = NULL;
        while (cur)
        {
            if (key < cur->_key)//找的数比根节点小，在左子树上继续找
            {
                parent = cur;
                cur = cur->_left;
            }
            else if (key > cur->_key)//找的数比根节点大，在右子树上继续找
            {
                parent = cur;
                cur = cur->_right;
            }
            else//找到了
            {
                if (cur->_left == NULL)//找到的节点的左为空
                {
                    if (parent == NULL)
                        _root = cur->_right;
                    else
                    {
                        if (cur == parent->_right)
                            parent->_right = cur->_right;
                        else
                            parent->_left = cur->_right;
                    }
                    del = cur;
                }
                else if (cur->_right == NULL)//找到的节点右为空（包括左右都为空的）
                {
                    if (parent == NULL)
                        _root = cur->_left;
                    else
                    {
                        if (cur == parent->_left)
                            parent->_left = cur->_left;
                        else
                            parent->_right = cur->_left;
                    }
                    del = cur;
                }
                else//找到的节点左右都不为空，用替换法删除(左子树的最右节点，右子树的最左节点)
                {
                    Node* subNode = cur->_left;
                    Node* tmp = cur;
                    while (subNode->_right)
                    {
                        tmp = subNode;
                        subNode = subNode->_right;
                    }
                    swap(subNode->_key, cur->_key);
                    if (subNode == tmp->_left)
                        tmp->_left = subNode->_right;
                    else
                        tmp->_right = subNode->_right;
                    del = subNode;
                }
                delete del;
                del = NULL;
                return true;
            }
        }
        return false;
    }

递归：

bool _RemoveR(Node*& cur,size_t key)
    {
        if (cur == NULL)
        {
            return false;
        }
        if (key < cur->_key)
        {
            _RemoveR(cur->_left, key);
        }
        else if (key > cur->_key)
        {
            _RemoveR(cur->_right, key);
        }
        else
        {
            Node* del = cur;
            if (cur->_left == NULL)
            {
                cur = cur->_left;
            }
            else if (cur->_right == NULL)
            {
                cur = cur->_right;
            }
            else
            {
                Node* parent = cur;
                Node* subNode = cur->_left;
                while (subNode->_right)
                {
                    parent = subNode;
                    subNode = subNode->_right;
                }
                swap(subNode->_key, cur->_key);
                if (parent->_right = subNode)
                    parent->_right = subNode->_right;
                else
                    parent->_left = subNode->_right;
                del = subNode;
            }
            delete del;
            del = NULL;
            return true;
        }
        return false;
    }

代码实现：

"SearchBinaryTree.h"
#pragma once

template <class K>
struct SearchBinaryTreeNode
{
    K _key;
    SearchBinaryTreeNode<K>* _left;
    SearchBinaryTreeNode<K>* _right;

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

template <class K>
class SearchBinaryTree
{
    typedef SearchBinaryTreeNode<K> Node;
public:
    SearchBinaryTree()//无参构造
        :_root(NULL)
    {}
    SearchBinaryTree(K* a, size_t n)//构造函数
    {
        _root = NULL;
        for (size_t i = 0; i < n; ++i)
        {
            InsertR(a[i]);
        }
    }

    ~SearchBinaryTree()
    {
        _Destory(_root);
    }

    bool Insert(const K& key)//非递归插入
    {
        if (_root == NULL)
        {
            _root = new Node(key);
            return true;
        }
        Node* cur = _root;
        Node* parent = NULL;
        while (cur)
        {
            parent = cur;
            if (key > cur->_key)
            {
                cur = cur->_right;
            }
            else if (key < cur->_key)
            {
                cur = cur->_left;
            }
            else
            {
                return false;
            }
        }
        if (key < parent->_key)
        {
            parent->_left = new Node(key);
        }
        else
        {
            parent->_right = new Node(key);
        }
        return true;
    }
    bool InsertR(const K& key)
    {
        return _InsertR(_root, key);
    }
    bool Remove(const K& key)
    {
        if (_root == NULL)//空树，删除不了 ，返回false
            return false;
        Node* cur = _root;
        Node* parent = NULL;
        Node* del = NULL;
        while (cur)
        {
            if (key < cur->_key)//找的数比根节点小，在左子树上继续找
            {
                parent = cur;
                cur = cur->_left;
            }
            else if (key > cur->_key)//找的数比根节点大，在右子树上继续找
            {
                parent = cur;
                cur = cur->_right;
            }
            else//找到了
            {
                if (cur->_left == NULL)//找到的节点的左为空
                {
                    if (parent == NULL)
                        _root = cur->_right;
                    else
                    {
                        if (cur == parent->_right)
                            parent->_right = cur->_right;
                        else
                            parent->_left = cur->_right;
                    }
                    del = cur;
                }
                else if (cur->_right == NULL)//找到的节点右为空（包括左右都为空的）
                {
                    if (parent == NULL)
                        _root = cur->_left;
                    else
                    {
                        if (cur == parent->_left)
                            parent->_left = cur->_left;
                        else
                            parent->_right = cur->_left;
                    }
                    del = cur;
                }
                else//找到的节点左右都不为空，用替换法删除(左子树的最右节点，右子树的最左节点)
                {
                    Node* subNode = cur->_left;
                    Node* tmp = cur;
                    while (subNode->_right)
                    {
                        tmp = subNode;
                        subNode = subNode->_right;
                    }
                    swap(subNode->_key, cur->_key);
                    if (subNode == tmp->_left)
                        tmp->_left = subNode->_right;
                    else
                        tmp->_right = subNode->_right;
                    del = subNode;
                }
                delete del;
                del = NULL;
                return true;
            }
        }
        return false;
    }
    bool RemoveR(const K& key)
    {
        return _RemoveR(_root, key);
    }
    bool Find(const K& key)
    {
        if (_root == NULL)
            return false;
        Node* cur = _root;
        while (cur)
        {
            if (key < cur->_key)
            {
                cur = cur->_left;
            }
            else if (key > cur->_key)
            {
                cur = cur->_right;
            }
            else
            {
                return true;
            }
        }
        return false;
    }

    bool FindR(const K& key)
    {
        return _FindR(_root, key);
    }

    void InOrder()
    {
        _InOrder(_root);
        cout << endl;
    }
protected:
    bool _FindR(Node*& cur, size_t key)
    {
        if (cur == NULL)
            return false;
        if (key < cur->_key)
        {
            _FindR(cur->_left, key);
        }
        else if (key > cur->_key)
        {
            _FindR(cur->_right, key);
        }
        else
        {
            return true;
        }
        return false;
    }
    bool _RemoveR(Node*& cur,size_t key)
    {
        if (cur == NULL)
        {
            return false;
        }
        if (key < cur->_key)
        {
            _RemoveR(cur->_left, key);
        }
        else if (key > cur->_key)
        {
            _RemoveR(cur->_right, key);
        }
        else
        {
            Node* del = cur;
            if (cur->_left == NULL)
            {
                cur = cur->_left;
            }
            else if (cur->_right == NULL)
            {
                cur = cur->_right;
            }
            else
            {
                Node* parent = cur;
                Node* subNode = cur->_left;
                while (subNode->_right)
                {
                    parent = subNode;
                    subNode = subNode->_right;
                }
                swap(subNode->_key, cur->_key);
                if (parent->_right = subNode)
                    parent->_right = subNode->_right;
                else
                    parent->_left = subNode->_right;
                del = subNode;
            }
            delete del;
            del = NULL;
            return true;
        }
        return false;
    }
    bool _InsertR(Node*& cur, size_t key)
    {
        if (cur == NULL)
        {
            cur = new Node(key);
            return true;
        }

        if (key < cur->_key)
        {
            _InsertR(cur->_left,key);
        }
        else if(key > cur->_key)
        {
            _InsertR(cur->_right,key);
        }
        else
        {
            return false;
        }
    }
    void _Destory(Node* cur)
    {
        if (cur == NULL)
            return;

        _Destory(cur->_left);
        _Destory(cur->_right);
        delete cur;
        cur = NULL;
    }
    void _InOrder(Node*& cur)
    {
        if (cur == NULL)
            return;
        _InOrder(cur->_left);

        cout << cur->_key << " ";
        _InOrder(cur->_right);
    }
protected:
    Node* _root;
};

void TestSearchBinaryTree()
{
    int a[] = { 5, 1, 2, 8, 3, 9, 4, 6, 7, 0 };
    SearchBinaryTree<int> t(a,sizeof(a)/sizeof(a[0]));
}
"Test.cpp"
#include <iostream>
using namespace std;
#include "SearchBinaryTree.h"

int main()
{
    TestSearchBinaryTree();
    return 0;
}
simplehap
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
搜索二叉树c语言版本
08-13
搜索二叉树（Binary Search Tree，简称BST）是一种特殊的二叉树数据结构，它具有以下特性：对于树中的任意一个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。...
js实现搜索二叉树.rar
06-08
在JavaScript中实现二叉树是一种常见且重要的编程技巧，它涉及到数据结构和算法的理解。二叉树是一种非线性数据结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。在这个主题中，我们将深入探讨如何使用...
二叉树搜索
weixin_34122810的博客
07-07 66
删除数值一般来说，须要依据以下几种情况分别进行处理： 1.须要删除的节点没有左儿子，那么把右儿子提上去 2.须要删除的节点的左儿子没有右儿子，那么就把左儿子提上去 3.以上两种情况都不满足的话，就把左儿子的子孙中最大的节点提到须要删除的节点上 和堆一样。非常多情况下不须要自己实现二叉搜索树，使用C++中的STL，STL里有set和map容器， set是使用erc搜索树维护集合的容器，而...
查找二叉树（BST）
WHTGS的博客
03-04 236
今天分享一些关于BST的内容： 一、基础知识点 1 一棵树最上面的节点称为根节点，如果一个节点下面连接多个节点，那么该节点称为父节点，，，它下面的节点称为子节点。一个节点可以有0个 1个 或多个子节点，没有任何子节点的节点称为叶子节点 2 以某种特定的顺序访问树中所有的节点称为树的遍历 3 树可以分为几个层次，根节点是第0层，子节点是第1层，子节点的子节点是第2层，依次类推 二、今天的主角...
查找二叉树（树）
chrisblogtk的博客
04-08 1713
Description 已知一棵二叉树用邻接表结构存储，中序查找二叉树中值为x的结点，并指出是第几个结点 Input 第一行为二叉树的结点个数，n Output 输出一个数即查找的结点编号 Sample Input   7 15  5 2 3  12 4 5  10 0 0  29 0 0  15 6 7  8 0 0  23 0 0   Samp
【数据结构】——搜索二叉树的插入，查找和删除（递归&非递归）
02-26
【数据结构】——搜索二叉树的插入，查找和删除（递归&非递归） 在计算机科学中，数据结构是存储和组织数据的方式，它直接影响到数据的处理效率。搜索二叉树（BST，Binary Search Tree）是一种特殊类型的数据结构，...
数据结构搜索二叉树.rar
07-16
二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树...
搜索二叉树的各种操作 创建 查找 遍历 插入 删除
01-20
搜索二叉树的各种操作 创建 查找 遍历 插入 删除 在GCC下编译通过。
查找二叉树
Genius_panda_ACM的博客
08-10 578
题目描述 已知一棵二叉树用邻接表结构存储，中序查找二叉树中值为x的结点，并指出是 第几个结点。 输入        第一行n为二叉树的结点个树，n&lt;=100；第二行x表示要查找的结点的值；以下第一列数据是各结点的值，第二列数据是左儿子结点编号，第三列数据是右儿子结点编号。 输出 输出要查找的结点数目。 样例输入 7 15 5 2 3 12 4 5 10 0 0 29 0...
搜索——搜索二叉树
小白cvnice的博客
10-05 122
搜索二叉树概念： 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 程序： class Node(): """创建树节点""" def __init__(self,val=None, left = None, rig...
二叉树——搜索二叉树
weixin_68644350的博客
10-23 823
详解二叉搜索树的实现以及时间复杂度和缺陷
C++实现搜索二叉树
最新发布
05-30
可以使用结构体和指针来实现搜索二叉树，具体实现方法如下： ```c++ #include using namespace std; // 定义二叉树节点结构体 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x)...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值