搜索二叉树的实现

最新推荐文章于 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
    评论
专栏目录
二叉搜索树的实现
缥缈烟雨
05-13 667
1.二叉搜索树又称为二叉查找树(二叉排序树),可以是一颗空树，若不是空树具备以下性质:   1)若左子树不为空，则左子树上的所有节点值均小于根节点的值 2）若右子树不为空，则右子树上所有节点的值都大于根节点的值   3）它的左右子树也分别为二叉搜索树，即具有和根节点相同的性质2.二叉搜索树的插入    1）空树        2)树不为空，根据其性质进行查找插入位置，然后插入新节点3.二叉搜索树的...
二叉搜索树实现
突破吧！次元壁
07-18 112
import java.util.ArrayList; import java.util.NoSuchElementException; import java.util.Random; public class forTest { public static void main(String[] args) { SearchBinaryTree t = new SearchBinaryTree(); Random r =new Random();
3D数学在Unity中运用
02-28
本课程主要是讲解3D数学知识在Unity中是如何运用？从坐标系到向量，矩阵，以及二叉树，行为树AI算法等知识讲解。将3D数学理论知识与实际开发结合起来。
轻松搞定面试中的二叉树题目
热门推荐
计算机的艺术
08-29 26万+
版权所有，转载请注明出处，谢谢！ http://blog.csdn.net/walkinginthewind/article/details/7518888 树是一种比较重要的数据结构，尤其是二叉树。二叉树是一种特殊的树，在二叉树中每个节点最多有两个子节点，一般称为左子节点和右子节点（或左孩子和右孩子），并且二叉树的子树有左右之分，其次序不能任意颠倒。二叉树是递归定义的，因此，与二叉树有关
【数据结构】二叉树的实现
最新发布
m0_72651735的博客
05-02 31
而第二种情况是队列不为空，但在访问队头节点时访问到了 NULL，这时我们需要再次进行循环，若队列不为空，就进入循环逐个查找并删除队头的节点，若发现不为空的节点，说明节点间有 NULL 相隔，即该二叉树不是完全二叉树，返回false。设二叉树的根节点所在层数为 1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第 2 层上的节点，接着是第三层的节点，以此类推。若节点不为空，但节点的值不是我们要查找的值，就查找节点的左子树，如果查找的结果不为空，就返回该节点。
Unity C#二叉排序树的原理及泛型写法详解（图文）
cube454517408的专栏
07-14 944
目录 1.简介 2.性质 3.泛型声明 4.树的结构 5.查找 6.插入 7.遍历 8.删除 9.示例 1.简介 二叉排序树：顾名思义它是一颗具有一定访问顺序的二叉树，通过中序遍历可以得到一个有序的序列 2.性质 一颗二叉排序树可以是空树，当它是非空树时具有以下特性： 1）当它的左子树不为空时，所有左子节点的值均小于根节点的值 2）当它的右子树不为空时，所有右子节点的值均大于根节点的值 3）它的左右子树均为二叉排序树 3.泛型声明 泛型数据需实现IComparerSear
unity（C#）实现二叉树（2）
weixin_51481499的博客
12-27 1017
功能实现： //直接复制（可用） using System; using System.Collections; using System.Collections.Generic; using UnityEngine; public class BST2<Key, Value> where Key : IComparable<Key> { private class Node { public Key key; public V
数据结构——二叉搜索树
m0_57249790的博客
03-30 6015
遍历数组中的水果，当遇到相同的水果时只在结点的value上进行++操作，以至于来计算每个水果出现的次数，最后中序遍历输出。将minright的值赋给cur然后直接使cur的右结点变为minright的右结点。1、若删除的是根节点，那么直接让根结点指向原根结点的右子树。1、若删除的是根节点，那么直接让根结点指向原根结点的左子树。2、若删除的不是根节点，那么将它的子树托孤给它的父节点。2、 若所需要删除的结点的右结点不是其右子树的最左结点。1、若所需要删除的结点的右结点是其右子树的最左结点。
C++实现二叉树搜索树
12-18
功能：插入、查找、删除、清除整个树、返回最大值、返回最小值、前序遍历、中序遍历、后序遍历。 注：此二叉树允许插入相同的值
js实现搜索二叉树.rar
06-08
在JavaScript中实现二叉树是一种常见且重要的编程技巧，它涉及到数据结构和算法的理解。二叉树是一种非线性数据结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。在这个主题中，我们将深入探讨如何使用...
C语言实现二叉树的搜索及相关算法示例
08-30
C语言实现二叉树的搜索及相关算法示例 本文主要介绍了C语言实现二叉树的搜索及相关算法，结合具体实例形式分析了基于C语言创建、遍历、搜索等相关算法与实现技巧。 一、 二叉树的基本概念 二叉树是一种特殊的树形...
二叉树实现
06-24
在IT领域，二叉树是一种基础...以上就是关于“二叉树实现”的主要内容，希望对您理解二叉树及其在C语言中的实现有所帮助。对于更复杂的应用，如平衡二叉树（AVL树、红黑树等）以及树的其他操作，需要进一步学习和实践。
C++二叉树实现词频分析功能
08-28
C++二叉树实现词频分析功能 C++二叉树实现词频分析功能是通过使用二叉树数据结构来实现对词频的分析和统计，主要用于文本处理和信息检索领域。这种方法可以实现高效的词频统计和查询操作。 知识点一：二叉树数据...
数据结构——（超详细，超简单）二叉树的实现
weixin_67452474的博客
09-25 3555
二叉树实现
二叉搜索树
m0_53421868的博客
12-20 3666
二叉搜索树 二叉搜索树概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 插入 //增删查改 bool insert(const T& val) { Node* node = new Node(val); if (!_root) { _root = node; } else { Node*.
数据结构之二叉树的实现
weixin_68624665的博客
04-09 1077
之前给大家介绍了有关堆的实现，那么这里小编就给大家带来今天的重头戏——二叉树的实现，以及介绍。
二叉树的实现
qq_50743381的博客
05-27 1391
二叉树 1、二叉树结构简介 在进行链表结构开发的过程之中会发现所有的数据按照首尾相连的状态进行保存，那么当要进行某一个数据查询的时候（判断该数据是否存在），这种情况下它所面对的时间复杂度是“O(n)”，如果说现在它的数据量小，这样的情况下，性能上是不会有太大差别的，但是一旦保存的数据量很大，这个时候时间负责度就会严重很多，严重损耗程序的运行性能。这个时候对于数据的存储结构就必须发生改变，应该可以尽可能的减少检索次数为出发点进行设计，对于现在的数据结构而言，最好的性能就是“O(logn)”。所以要想实现它就可
数据结构——搜索二叉树
weixin_67401157的博客
08-02 821
数据结构——搜索二叉树
二叉查找树
码农笔记
10-25 7370
二叉查找树是二叉树中最常用的一种类型，也叫二叉搜索树。顾名思义，二叉查找树是为了实现快速查找而生的。不过，它不仅仅支持快速查找一个数据，还支持快速插入、删除一个数据。它是怎么做到这些的呢？ 这些都依赖于二叉查找树的特殊结构。二叉查找树要求，在树中的任意一个节点，其左子树中的每个节点的值，都要小于这个节点的值，而右子树节点的值都大于这个节点的值。 ...
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、付费专栏及课程。

余额充值