搜索二叉树的实现

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

要模拟实现搜索二叉树，必须了解他的性质：
搜索二叉树的性质：
1，每个节点都有一个用于搜索的关键码，每个节点的关键码都不一样；
2，一个节点的左子树上所有的关键码总是小于它，而右子树的关键总是大于它；
3，每一个子树都是一个搜索二叉树；

这里简单来模拟实现一下搜索二叉树（递归和非递归）：
插入：
当插入一个节点时，你会发现新插入节点不会影响原先树的结构，所以不用调整，这是简单之处。

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

删除：
先遍历搜索树找到删除节点，下面主要分三种情况：
1，删除节点无左子树；
2，删除节点无右子树；
3，左右子树都有。
这里写图片描述
对于1,2两种情况，如果该节点是根节点时，只需将他仅有的那个孩子的根节点设为新的根节点即可，如果不是根节点，删除这个节点，还需将父节点与他的子树连接在一起，这种情况下，你就得判断自己是父节点的左孩子还是右孩子。而对于3这种情况，你需找一个新的节点来替代它，这里删这个节点不是真的删他自己，而是删了一个替代节点，替代节点有两个选择：左子树的最右节点（左子树最大值），右子树的最左节点（右子树最小值），找到替代节点，将他的关键码赋给待删除节点，然后删除它即可，但这里还有一个关键得注意（这里替代节点取右子树最左节点为例），这个最左节点的父节点可能是根节点，也可能不是，这里影响后面的连接。

    bool _Remove(const K& x)
    {
        if (_root == NULL)
            return false;
        Node* del = _root;
        Node* parent = del;
        while (del)
        {
            if (del->_key == x) //被删除的节点找到（左为空，右为空，左右均不为空）
            {
                Node* cur = del;
                if (cur->_left == NULL)   //删除节点无左子树
                {
                    if (cur == _root)
                        _root = _root->_right;
                    else
                    {
                        if (parent->_left == cur)
                            parent->_left = cur->_right;
                        else
                            parent->_right = cur->_right;
                    }
                }
                else if (cur->_right == NULL)   //删除节点无右子树
                {
                    if (cur == _root)
                        _root = _root->_left;
                    else
                    {
                        if (parent->_left == cur)
                            parent->_left = cur->_left;
                        else
                            parent->_right = cur->_left;
                    }
                }
                else  //左右子树都有
                {
                    cur = cur->_right;
                    while (cur->_left)
                    {
                        parent = cur;
                        cur = cur->_left;
                    }
                    del->_key = cur->_key;
                    del = cur;

                    if (cur == parent->_left)    //注意，此时的cur是最左节点
                        parent->_left = cur->_right;
                    else                         //此时的cur为根节点的右子树的根节点，parent为根节点
                        parent->_right = cur->_right;
                }
                delete del;
                del = NULL;

                return true;
            }
            else if (del->_key > x)
            {
                parent = del;
                del = del->_left;
            }
            else
            {
                parent = del;
                del = del->_right;
            }
        }
        return false;
    }


    bool  _RemoveR(const K& x, Node* & root)
    {
        if (root == NULL)
            return false;

        if (root->_key > x)
            _RemoveR(x, root->_left);
        else if (root->_key < x)
            _RemoveR(x, root->_right);
        else  //找到删除的位置
        {
            Node* del = root;
            if (root->_left == NULL)
            {
                root = root->_right;
            }
            else if (root->_right == NULL)
            {
                root = root->_left;
            }
            else
            {
                Node* parent = root->_right;
                Node* rootL = root->_right;
                while (rootL->_left)
                {
                    parent = rootL;
                    rootL = rootL->_left;
                }
                root->_key = rootL->_key;
                del = rootL;

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

        }
    }

查找：

    Node* _Find(Node* root, const K& x)
    {
        while (root)
        {
            if (x > root->_key)
                root = root->_right;
            else if (x < root->_key)
                root = root->_left;
            else
                return root;
        }
        return NULL;
    }


Node* _FindR(Node* root, const K& x)
    {
        if (x > root->_key)
            return _FindR(root->_right, x);
        else if (x < root->_key)
            return _FindR(root->_left, x);
        else
        {
            return root;
        }
        return NULL;
    }

下面是完整代码：

#include<iostream>

using namespace std;

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

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

};

template<class K>
class SearchBinaryTree
{
    typedef SearchBinaryTreeNode<K> Node;

public:
    SearchBinaryTree()
        :_root(NULL)
    {}

    ~SearchBinaryTree()
    {
        _Delete(_root);
    }
    void Insert(const K& x)
    {
        _Insert(x);
    }

    bool Remove(const K& x)
    {
        return _Remove(x);
    }

    void RemoveR(const K& x)
    {
        _RemoveR(x, _root);
    }

    Node* FindR(const K& x)
    {
        return _FindR(_root,x);
    }

    Node* Find(const K& x)
    {
        return _Find(_root,x);
    }
    void InOrder()
    {
        _InOrder(_root);
        cout << endl;
    }

private:

    void _Delete(Node*& root)
    {
        if (root == NULL)
            return;
        _Delete(root->_left);
        _Delete(root->_right);
        delete root;
        root = NULL;
    }

    Node* _Find(Node* root, const K& x)
    {
        while (root)
        {
            if (x > root->_key)
                root = root->_right;
            else if (x < root->_key)
                root = root->_left;
            else
                return root;
        }
        return NULL;
    }

    Node* _FindR(Node* root, const K& x)
    {
        if (x > root->_key)
            return _FindR(root->_right, x);
        else if (x < root->_key)
            return _FindR(root->_left, x);
        else
        {
            return root;
        }
        return NULL;
    }



    void _InOrder(Node* root)
    {
        if (root)
        {
            _InOrder(root->_left);
            cout << root->_key << " ";
            _InOrder(root->_right);
        }
    }

    bool _Insert(const K& x)
    {
        if (_root == NULL)
        {
            _root = new Node(x);
        }
        else
        {
            Node* cur = _root;
            //Node* newNode = new Node(x);
            Node* parent = cur;
            while (cur)
            {
                if (cur->_key > x)
                {
                    parent = cur;
                    cur = cur->_left;
                }
                else if (cur->_key < x)
                {
                    parent = cur;
                    cur = cur->_right;
                }
                else
                {
                    return false;
                }
            }
            if (parent->_key > x)
            {
                parent->_left = new Node(x);
            }
            else
            {
                parent->_right = new Node(x);
            }
        }
        return true;
    }

    //删除一个数
    //1，叶子节点/左子树为空或右子树为空
    //2，左右子树均不为空
    bool _Remove(const K& x)
    {
        if (_root == NULL)
            return false;
        Node* del = _root;
        Node* parent = del;
        while (del)
        {
            if (del->_key == x) //被删除的节点找到（左为空，右为空，左右均不为空）
            {
                Node* cur = del;
                if (cur->_left == NULL)   //删除节点无左子树
                {
                    if (cur == _root)
                        _root = _root->_right;
                    else
                    {
                        if (parent->_left == cur)
                            parent->_left = cur->_right;
                        else
                            parent->_right = cur->_right;
                    }
                }
                else if (cur->_right == NULL)   //删除节点无右子树
                {
                    if (cur == _root)
                        _root = _root->_left;
                    else
                    {
                        if (parent->_left == cur)
                            parent->_left = cur->_left;
                        else
                            parent->_right = cur->_left;
                    }
                }
                else  //左右子树都有
                {
                    cur = cur->_right;
                    while (cur->_left)
                    {
                        parent = cur;
                        cur = cur->_left;
                    }
                    del->_key = cur->_key;
                    del = cur;

                    if (cur == parent->_left)    //注意，此时的cur是最左节点
                        parent->_left = cur->_right;
                    else                         //此时的cur为根节点的右子树的根节点，parent为根节点
                        parent->_right = cur->_right;
                }
                delete del;
                del = NULL;

                return true;
            }
            else if (del->_key > x)
            {
                parent = del;
                del = del->_left;
            }
            else
            {
                parent = del;
                del = del->_right;
            }
        }
        return false;
    }

    bool  _RemoveR(const K& x, Node* & root)
    {
        if (root == NULL)
            return false;

        if (root->_key > x)
            _RemoveR(x, root->_left);
        else if (root->_key < x)
            _RemoveR(x, root->_right);
        else  //找到删除的位置
        {
            Node* del = root;
            if (root->_left == NULL)
            {
                root = root->_right;
            }
            else if (root->_right == NULL)
            {
                root = root->_left;
            }
            else
            {
                Node* parent = root->_right;
                Node* rootL = root->_right;
                while (rootL->_left)
                {
                    parent = rootL;
                    rootL = rootL->_left;
                }
                root->_key = rootL->_key;
                del = rootL;

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

        }
    }

    Node* _root;
};

下面是测试代码：

void Test()
{
    SearchBinaryTree<int> tree;
    tree.Insert(5);
    tree.Insert(1);
    tree.Insert(2);
    tree.Insert(3);
    tree.Insert(4);
    tree.Insert(9);
    tree.Insert(8);
    tree.Insert(6);
    tree.Insert(7);

    tree.RemoveR(5);
    tree.RemoveR(4);
    tree.RemoveR(1);
    tree.RemoveR(9);
    tree.RemoveR(2);
    tree.RemoveR(3);
    tree.RemoveR(6);
    tree.RemoveR(7);
    tree.RemoveR(8);
    //cout << tree.FindR(5) << endl;
    //cout << tree.Find(5) << endl;
    //cout << tree.Find(9) << endl;
    //cout << tree.Find(9) << endl;

    tree.~SearchBinaryTree();

    tree.InOrder();

}

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

分析

搜索二叉树的退化和缺陷：
这里写图片描述

搜索二叉树找一个数的运行效率取决于它的形状（N个节点），最好的情况是满二叉树，这时总共lgN层，时间复杂度是lgN，最差的情况是上图所示，总共N层。这时它的时间复杂度是N，这是因为这棵树已经不平衡了，对于最好的情况（满二叉树），可以参考二分查找。
对于上述问题，下篇文章会介绍到高度平衡的二叉搜索树，即 AVL树。

pg_dog
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
轻松搞定面试中的二叉树题目
计算机的艺术
08-29 26万+
版权所有，转载请注明出处，谢谢！ http://blog.csdn.net/walkinginthewind/article/details/7518888 树是一种比较重要的数据结构，尤其是二叉树。二叉树是一种特殊的树，在二叉树中每个节点最多有两个子节点，一般称为左子节点和右子节点（或左孩子和右孩子），并且二叉树的子树有左右之分，其次序不能任意颠倒。二叉树是递归定义的，因此，与二叉树有关
数据结构——二叉树的实现
勇气是明知不可为而为之
07-11 545
二叉树（binary tree）是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。
【数据结构】二叉树的实现
最新发布
m0_72651735的博客
05-02 31
而第二种情况是队列不为空，但在访问队头节点时访问到了 NULL，这时我们需要再次进行循环，若队列不为空，就进入循环逐个查找并删除队头的节点，若发现不为空的节点，说明节点间有 NULL 相隔，即该二叉树不是完全二叉树，返回false。设二叉树的根节点所在层数为 1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第 2 层上的节点，接着是第三层的节点，以此类推。若节点不为空，但节点的值不是我们要查找的值，就查找节点的左子树，如果查找的结果不为空，就返回该节点。
搜索二叉树(超详解)
庖丁解牛，恢恢乎游刃有余
12-23 1485
普通二叉树其实意义不大，如果用二叉树存储数据的话，还不如顺序表，链表这些。搜索二叉树它的意义就很大了。左边比根小，右边比根大，子树也满足这个特征。
二叉搜索树的实现
qq_62905847的博客
11-08 457
java详细实现二叉搜索树
C++实现二叉树搜索树
12-18
功能：插入、查找、删除、清除整个树、返回最大值、返回最小值、前序遍历、中序遍历、后序遍历。 注：此二叉树允许插入相同的值
js实现搜索二叉树.rar
06-08
在JavaScript中实现二叉树是一种常见且重要的编程技巧，它涉及到数据结构和算法的理解。二叉树是一种非线性数据结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。在这个主题中，我们将深入探讨如何使用...
C语言实现二叉树的搜索及相关算法示例
08-30
C语言实现二叉树的搜索及相关算法示例 本文主要介绍了C语言实现二叉树的搜索及相关算法，结合具体实例形式分析了基于C语言创建、遍历、搜索等相关算法与实现技巧。 一、 二叉树的基本概念 二叉树是一种特殊的树形...
二叉树实现
06-24
在IT领域，二叉树是一种基础...以上就是关于“二叉树实现”的主要内容，希望对您理解二叉树及其在C语言中的实现有所帮助。对于更复杂的应用，如平衡二叉树（AVL树、红黑树等）以及树的其他操作，需要进一步学习和实践。
C++二叉树实现词频分析功能
08-28
C++二叉树实现词频分析功能 C++二叉树实现词频分析功能是通过使用二叉树数据结构来实现对词频的分析和统计，主要用于文本处理和信息检索领域。这种方法可以实现高效的词频统计和查询操作。 知识点一：二叉树数据...
数据结构之搜索二叉树
qq_56999918的博客
11-24 1038
目录 搜索二叉树基本介绍： 二叉搜索树的插入： 二叉搜索树的查找： 二叉搜索树的删除： 普通二叉树的删除： 搜索二叉树基本介绍： 1.二叉搜索树的概念： 二叉搜索树又称二叉查找树，亦称为二叉排序树。设x为二叉查找树中的一个节点，x节点包含关键字key，节点x的key值记为key[x]。如果y是x的左子树中的一个节点，则key[y] <= key[x]；如果y是x的右子树的一个节点，则key[y] >= key[x]。 2.二叉搜索树的性质： （1）若左子树不...
二叉树的实现（C语言数据结构）
芊樱烛渊的博客
05-23 9591
一、以下是我们需要实现的功能 #pragma once #include <stdio.h> #include <stdlib.h> #include <assert.h> #include <stdbool.h> typedef char BTDataType; typedef struct BinaryTreeNode { BTDataType _data; struct BinaryTreeNode* _left; stru
二叉树的实现（C语言）
m0_70403090的博客
09-11 2604
如果数组a【*pi】不为空，就开辟空间来存储a【*pi】，同时（*pi）++。然后依次根据左子树，右子树来递归建立树，遇到空时返回。只有遇到叶子节点的时候才会返回1，这样左右子树层层返回相加，最后计算出叶子节点个数。用lh和rh来比较大小，这样更深一层的树就会显示出来，包含了浅一层的树。也是依次层序遍历，然后在最后一层判断遇到空后是不是一直为空。由于树是链表结构，所以用递归来依次释放节点。二叉树是采用链表的结构来实现。在访问左右子树前先打印该节点。依然采用递归来计算节点个数。其中包含了队列的使用方式。
二叉搜索树详解与实现
a1912157861的博客
01-09 601
二叉搜索树详解与实现二叉搜索树概念二叉树的增删查改K类型二叉搜索树和KV类型二叉搜索树的底层代码实现 二叉搜索树概念 二叉搜索树又称二叉排序树，它具有以下这几种性质: 如果它的左子树不为空，则左子树上所有节点的值都小于根节点的值 如果它的右子树不为空，则右子树上所有节点的值都大于根节点的值 他的左右子树都是二叉搜索树 那么它为什么要叫做二叉排序树呢？ 因为它的中序遍历就是一个有序的数列，所以我们一般用中序遍历来遍历二叉搜索树，并且也可以使用二叉搜索树的这个特性来检查当前二叉树是否是二叉搜索树。 二叉树的
数据结构(C++)： 二叉搜索树 实现篇
weixin_57761086的博客
10-08 1506
讲解二叉搜索树的各种操作，在查找，插入，删除操作的讲解中，配置了大量插图，可以帮助读者清晰的了解每个过程。在二叉搜索树的实现中，也在代码中添加大量注释，帮助读者理解代码。
二叉树的查找
热门推荐
chenkaibsw的专栏
06-11 1万+
1）如果是二叉排序树在二叉排序树中查找某值，此时利用二叉排序树的性质，节点的左子树都是小于这个节点，节点的右子树都是大于这个节点的，所以从某节点node开始查找，如果在要找的值小于这个节点的值，就在左子树中查找，如果要找的值大于这个节点的值，就在该节点的右子树中查找，这里看出，最终查找后，从根节点到停止的节点，只有一条路径，所以二叉查找树的效率很高，如果一直找到叶子节点，还没有找到，就返回fals...
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、付费专栏及课程。

余额充值