搜索二叉树

于 2021-04-08 12:41:34 发布
阅读量479 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KOwzb/article/details/115510515
版权

二叉搜索树：它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。

二叉搜索树有个特点，最左的是最小的节点，最右的是最大的节点。
当我们把二叉搜索树进行中序遍历的时候，它是进行排序后的结果，所以我们也把二叉搜索树叫做排序二叉树。

接下来我们介绍二叉排序树的所有的算法：

1.1搜索二叉树的结构

首先我们来看它的结构，他的结构和二叉树类似，所以会有一个左孩子节点的指针，一个右孩子节点的指针，还有一个被叫做键值的东西，我们通常来采用这个构建搜索二叉树，然后还有一个叫做关键值，我们用它来保存数据。

template<typename K,typename V>
struct SearchBinaryTreeNode
{
    typedef SearchBinaryTreeNode<K,V> Node;

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

    {
    }


    V _value;
    Node* _left;
    Node* _right;
    K _key;

};

1.2构建搜索二叉树

SearchBinaryTree(const K* arr, size_t size)
    {
        assert(arr);
        for (size_t i = 0; i < size; i++)
        {
            InsertP(arr[i]);
        }

    }

把数组中的每一个元素作为节点，进行插入。

1.3搜索二叉树的插入

搜索二叉树关键的算法之一，在这里，我们的思路就是当你插入一个节点，必须是所指向的位置为空时才可以查入，所以我们来查找我们所需要插入的位置，如果为空树，那么可以直接进行插入。
其他的用根节点的键值和key进行比较，如果key大于根节点键值，就说明在右子树如果小，那么就说明在右子树，如果相等，就说明已经出现了，不需要再次进行插入。最后如果我们所找到的位置为空那么这个时候我们就可以进行插入，插入的时候要看与父亲节点的key进行比较，如果小插入右边，如果大，插入左边。
这里写图片描述

    bool Insert(const K& key)
    {
        if (_root == NULL)
        {
            _root = new Node(key);
            return true;
        }
        Node *cur = _root;
        Node *parent = _root;
        while (cur)
        {
            if (cur->_key < key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (curcur->_key>key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else
            {
                return false;
            }
        }
        Node *tmp = new Node(key);
        if (key > parent->_key)
        {

            parent->_right = tmp;
        }
        else
        {
            parent->_left = tmp;
        }
        return true;
    }

 

上面完成的是非递归的插入，另外，我们实现递归的插入，思路是一样的。

递归的插入在最后只有找到为空的时候才能进行插入节点，否则就进行递归。

    bool _InsertP(Node *&root, const K& key)
    {
        if (root == NULL)
        {
            root = new Node(key);
            return true;
        }
        if (root->_key > key)
        {
            _InsertP(root->_left, key);
        }
        else if (root->_key < key)
        {
            _InsertP(root->_right, key);
        }
        else
        {
            return false;
        }
        return true;
    }

1.4搜索二叉树的删除

搜索二叉树的删除算法算是最难的了。在这里我们需要考虑几种思路。

  • 没有这个节点
  • 删除根节点
  • 删除左子树为空的节点
  • 删除右子树为空的节点
  • 删除左右子书都不为空的节点

这里写图片描述

首先我们要做的是找到这个节点，然后找到这个节点的算法就类似与查找节点。
接下来我们要做的是分情况进行讨论。

如果没有这个节点，我们就不删了，return。

接下来看它的孩子，当它孩子任意一个为空的时候，看他的孩子时要考虑删除根节点的情况。删除根节点，这个时候终点是改变root，另外的删除其他节点，找到这个节点，然后看这个节点和父亲节点的关系，进行调整就好了。

然后，进行讨论两个孩子都有的情况，首先我们就是利用交换的方式进行删除，思路就是找到删除节点的第一个右子树节点的最左节点或者左子树第一个节点的最右节点。简单的说，就是把根变作左子树最大的或者右子树最小的。

综合这个思路我们就可以完成删除。
 

    bool Remove(const K& key)
    {
        Node *cur = _root;
        Node *parent = NULL;
        Node *del = NULL;
        while (cur&&cur->_key!=key)
        {
            if (cur->_key < key)
            {

                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_key>key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else
            {
                break;
            }
        }
        if (cur == NULL)
        {
            return false;   
        }
        if (cur->left == NULL)
        {

            del = cur;
            if (parent == NULL)
            {
                _root = cur->_right;
            }
            else
            {

                if (parent->_left == cur)
                {
                    parent->_left = cur->_right;
                }
                else
                {
                    parent->_right = cur->_right;
                }
            }
        }
        else if (cur->_right==NULL)
        {
            del = cur;
            if (parent == NULL)
            {
                cur = cur->_left;
            }
            else
            {
                if (parent->_left == cur)
                {
                    parent->_left = cur->_left;
                }
                else
                {
                    parent->_right = cur->_right;
                }
            }

        }
        else
        {
            Node *swapnode = cur->_right;
            while (swapnode->_left)
            {
                parent = swapnode;
                swapnode = swapnode->_left;
            }
            del = swapnode;
            cur->_key = swapnode->_key;
            cur->_value = swapnode->_value;

            if (parent->_left == swapnode)
                parent->_left = swapnode->_right;
            else
                parent->_right = swapnode->_right;
        }
        delete del;
        del = NULL;
        return true;
    }

接下来介绍递归的删除：
递归的删除的思路和上面的是一样的，重点是在于理解递归。

递归的时候进行的也先是查找，如果找不到返回，找到进行删除。

这个时候我们也是一样，看root节点的孩子进行分布操作，如果左为空，那么就给root右，右为空，就给左，在这里，其实这个root的含义相当于是parent的左指针或右指针。因为是递归，所以就是上一层函数左指针或者右指针。然后其他的和上面的思路是一样的。
 

    bool _RemoveP(Node *&root, const K& key)
    {
        if (root == NULL)
        {
            return false;
        }
        if (root->_key < key)
        {
            _RemoveP(root->_right,key);
        }
        else if (root->_key > key)
        {
            _RemoveP(root->_left,key);
        }
        else
        {
            Node* del = root;


            if (root->_left == NULL)
            {
                root = root->_right;
            }
            else if (root->_right == NULL)
            {
                root = root->_left;
            }
            else
            {

                Node* parent = root;
                Node *swapnode = root->_right;
                while (swapnode->_left)
                {
                    parent = swapnode;
                    swapnode = swapnode->_left;
                }
                root->_key = swapnode->_key;
                root->_value = swapnode->_value;
                if (parent->_right == swapnode)
                    parent->_right = swapnode->_right;
                else
                    parent->_left = swapnode->_right;
                del = swapnode;
            }
            delete del;
            return true;
        }
        return false;
    }

1.5搜索二叉树的查找

搜索二叉树的查找，这个算法其实上面我们在删除已经进行过了，下面进行简单的介绍一下，你要搜索的，那么就是和根的key比较，如果大于根的key，那么就找右树，如果小于根的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 _FindP(Node * root,const K& key)
    {
        if (root == NULL)
        {
            return false;
        }
        if (key < root->_key)
        {
            return _FindP(root->_left, key);
        }
        else if (key>root->_key)
        {
            return _FindP(root->_right, key);
        }
        else
        {
            return true;
        }
        return false;
    }

1.5搜索二叉树的MAX和MIN

另外的算法就是找最小和最大
这两个算法就是查找算法的变形，一个是右子树的最右节点，一个是左子树的最左节点

    const K& Minvalue()
    {
        assert(_root);
        Node* cur = _root;
        while (cur->_left)
        {
            cur = cur->_left;
        }
        return cur->_value;
    }
    const K& Maxvalue()
    {
        assert(_root);
        Node *cur = _root;
        while (cur->_right)
        {
            cur = cur->_right;
        }
        return cur->_value;
    }

代码（全）

#pragma once

#include<iostream>
#include<cstdlib>
#include<cassert>
using namespace std;

template<typename K,typename V>
struct SearchBinaryTreeNode
{
    typedef SearchBinaryTreeNode<K,V> Node;

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

    {
    }


    V _value;
    Node* _left;
    Node* _right;
    K _key;

};

template<typename K,typename V>
class SearchBinaryTree
{
protected:
    typedef SearchBinaryTreeNode<K,V>  Node;

public:
    SearchBinaryTree(const K* arr, size_t size)
    {
        assert(arr);
        for (size_t i = 0; i < size; i++)
        {
            InsertP(arr[i]);
        }

    }
    ~SearchBinaryTree()
    {
        _root=_DestorySBT(_root);

    }
    bool InsertP(const K& key)
    {
        return _InsertP(_root, key);
    }
    bool Insert(const K& key)
    {
        if (_root == NULL)
        {
            _root = new Node(key);
            return true;
        }
        Node *cur = _root;
        Node *parent = _root;
        while (cur)
        {
            if (cur->_key < key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (curcur->_key>key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else
            {
                return false;
            }
        }
        Node *tmp = new Node(key);
        if (key > parent->_key)
        {

            parent->_right = tmp;
        }
        else
        {
            parent->_left = tmp;
        }
        return true;
    }
    bool RemoveP(const K& key)
    {
        return _RemoveP(_root, key);
    }
    bool Remove(const K& key)
    {
        Node *cur = _root;
        Node *parent = NULL;
        Node *del = NULL;
        while (cur&&cur->_key!=key)
        {
            if (cur->_key < key)
            {

                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_key>key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else
            {
                break;
            }
        }
        if (cur == NULL)
        {
            return false;   
        }
        if (cur->left == NULL)
        {

            del = cur;
            if (parent == NULL)
            {
                _root = cur->_right;
            }
            else
            {

                if (parent->_left == cur)
                {
                    parent->_left = cur->_right;
                }
                else
                {
                    parent->_right = cur->_right;
                }
            }
        }
        else if (cur->_right==NULL)
        {
            del = cur;
            if (parent == NULL)
            {
                cur = cur->_left;
            }
            else
            {
                if (parent->_left == cur)
                {
                    parent->_left = cur->_left;
                }
                else
                {
                    parent->_right = cur->_right;
                }
            }

        }
        else
        {
            Node *swapnode = cur->_right;
            while (swapnode->_left)
            {
                parent = swapnode;
                swapnode = swapnode->_left;
            }
            del = swapnode;
            cur->_key = swapnode->_key;
            cur->_value = swapnode->_value;

            if (parent->_left == swapnode)
                parent->_left = swapnode->_right;
            else
                parent->_right = swapnode->_right;
        }
        delete del;
        del = NULL;
        return true;
    }
    void Inorderprint()
    {
        _Inorderprint(_root);
        cout << endl;
    }
    bool Empty()
    {
        return _root == NULL;
    }
    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 FindP(const K &key)
    {
        return _FindP(_root, key);
    }
    const K& Top()
    {
        return _root->_key;
    }
    const K& Minvalue()
    {
        assert(_root);
        Node* cur = _root;
        while (cur->_left)
        {
            cur = cur->_left;
        }
        return cur->_value;
    }
    const K& Maxvalue()
    {
        assert(_root);
        Node *cur = _root;
        while (cur->_right)
        {
            cur = cur->_right;
        }
        return cur->_value;
    }
protected:
    Node* _DestorySBT(Node *root)
    {
        if (root != NULL)
        {
            root->_left = _DestorySBT(root->_left);
            root->_right = _DestorySBT(root->_right);
            delete root;
            root = NULL;
        }
        return root;
    }
    void _Inorderprint(Node *root)
    {
        if (root == NULL)
            return;
        _Inorderprint(root->_left);
        cout << root->_key << " ";
        _Inorderprint(root->_right);
    }
    bool _InsertP(Node *&root, const K& key)
    {
        if (root == NULL)
        {
            root = new Node(key);
            return true;
        }
        if (root->_key > key)
        {
            _InsertP(root->_left, key);
        }
        else if (root->_key < key)
        {
            _InsertP(root->_right, key);
        }
        else
        {
            return false;
        }
        return true;
    }
    bool _RemoveP(Node *&root, const K& key)
    {
        if (root == NULL)
        {
            return false;
        }
        if (root->_key < key)
        {
            _RemoveP(root->_right,key);
        }
        else if (root->_key > key)
        {
            _RemoveP(root->_left,key);
        }
        else
        {
            Node* del = root;


            if (root->_left == NULL)
            {
                root = root->_right;
            }
            else if (root->_right == NULL)
            {
                root = root->_left;
            }
            else
            {

                Node* parent = root;
                Node *swapnode = root->_right;
                while (swapnode->_left)
                {
                    parent = swapnode;
                    swapnode = swapnode->_left;
                }
                root->_key = swapnode->_key;
                root->_value = swapnode->_value;
                if (parent->_right == swapnode)
                    parent->_right = swapnode->_right;
                else
                    parent->_left = swapnode->_right;
                del = swapnode;
            }
            delete del;
            return true;
        }
        return false;
    }
    bool _FindP(Node * root,const K& key)
    {
        if (root == NULL)
        {
            return false;
        }
        if (key < root->_key)
        {
            return _FindP(root->_left, key);
        }
        else if (key>root->_key)
        {
            return _FindP(root->_right, key);
        }
        else
        {
            return true;
        }
        return false;
    }
protected:
    Node * _root;
};

 

KOwzb
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的查找
12-11
创建二叉排序树 的第一种方法（通过insertBST创建） 二叉排序树的查找 （递归实现） * * 查找可以有两种实现方法，一种是递归，一种是while 循环。 * 在插入和删除操作中也首先需要查询操作，这时使用while 循环比较好，可以知道要查询结点的双亲结点
搜索二叉树c语言版本
08-13
c语言实现的搜索二叉树。实现了对树的增加数据，删除数据，中序遍历数据。
二叉树搜索
weixin_34122810的博客
07-07 62
删除数值一般来说，须要依据以下几种情况分别进行处理： 1.须要删除的节点没有左儿子，那么把右儿子提上去 2.须要删除的节点的左儿子没有右儿子，那么就把左儿子提上去 3.以上两种情况都不满足的话，就把左儿子的子孙中最大的节点提到须要删除的节点上 和堆一样。非常多情况下不须要自己实现二叉搜索树，使用C++中的STL，STL里有set和map容器， set是使用erc搜索树维护集合的容器，而...
js实现搜索二叉树.rar
06-08
javascript实现二叉树 中序遍历 后序遍历 前序遍历 二叉树创建 中间节点的删除 叶子节点的删除
数据结构搜索二叉树.rar
07-16
二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树...
【数据结构】——搜索二叉树的插入，查找和删除（递归&非递归）
02-26
本代码是在windows平台下vs2008上编译通过，包含搜索二叉树的插入，查找和删除算法（采用递归和非递归两种方法）。包含全部在平台下的文件，解压可以直接运行。
搜索二叉树的各种操作 创建 查找 遍历 插入 删除
01-20
搜索二叉树的各种操作 创建 查找 遍历 插入 删除 在GCC下编译通过。
AVL搜索二叉树C语言源代码
12-07
用C语言实现AVL搜索二叉树，并且实现了一些基本的操作，比如判断树是否为空、获得节点数、获得树的高度、查找、中序遍历、层序遍历、AVL搜索二叉树节点的插入、节点的删除等等。并且附上详细的注释
查找插入删除搜索二叉树
11-19
用前序构造一个二叉树，左右结点以0结束，查找一个数，若搜索二叉树中有这个数，则把这个数删除并重新显示二叉树，若没有这个数，则将这个数插入到二叉树中并重新显示二叉树。
搜索二叉树（整型）
10-17
搜索二叉树（整型） C++.
深度优先搜索二叉树 C源码
04-24
DFS算法的非递归函数，数据结构图的搜索遍历之深度优先
81 – 判断列表是否为搜索二叉树后序遍历的结果
12-21
有一个整数型列表，判断该列表是否为对应二叉搜索树的后序遍历结果 ''' 二叉搜索树 二叉排序树 二叉查找树 前序遍历 中序遍历 后序遍历 根节点 算法： 1. 找到根节点 2. 遍历序列，找到第一个大于根节点的元素i，则i...
查找二叉树（BST）
WHTGS的博客
03-04 227
今天分享一些关于BST的内容： 一、基础知识点 1 一棵树最上面的节点称为根节点，如果一个节点下面连接多个节点，那么该节点称为父节点，，，它下面的节点称为子节点。一个节点可以有0个 1个 或多个子节点，没有任何子节点的节点称为叶子节点 2 以某种特定的顺序访问树中所有的节点称为树的遍历 3 树可以分为几个层次，根节点是第0层，子节点是第1层，子节点的子节点是第2层，依次类推 二、今天的主角...
搜索——搜索二叉树
小白cvnice的博客
10-05 116
搜索二叉树概念： 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 程序： class Node(): """创建树节点""" def __init__(self,val=None, left = None, rig...
C++实现搜索二叉树
最新发布
05-30
可以使用结构体和指针来实现搜索二叉树，具体实现方法如下： ```c++ #include <iostream> using namespace std; // 定义二叉树节点结构体 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; // 插入节点 void insert(TreeNode*& root, int val) { if (root == NULL) { root = new TreeNode(val); return; } if (root->val < val) { insert(root->right, val); } else { insert(root->left, val); } } // 中序遍历 void inorder(TreeNode* root) { if (root == NULL) return; inorder(root->left); cout << root->val << " "; inorder(root->right); } int main() { TreeNode* root = NULL; int n, val; cin >> n; for (int i = 0; i < n; i++) { cin >> val; insert(root, val); } inorder(root); return 0; } ``` 以上代码实现了搜索二叉树的插入和中序遍历。其中，插入操作使用了递归实现，中序遍历则使用了递归遍历左子树、节点、右子树的方式输出节点的值。可以通过输入一组数来测试代码是否正确。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值