二叉搜索树—增删查

最新推荐文章于 2022-08-15 11:34:57 发布
最新推荐文章于 2022-08-15 11:34:57 发布
阅读量344 收藏 1
点赞数
分类专栏： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ruina_bai/article/details/73741468
版权

性质
-每个节点的key值各不相同
-左子树上所有节点的key值小于根结点
-右子树上的所有节点key值大于根结点
-左右子树都是二叉搜索树

Insert插入

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 > parent->_key)
            {
                cur = parent->_right;
            }
            else if (key < parent->_key)
            {
                cur = parent->_left;
            }
            else
            {
                return false;
            }
        }
        //cur找到NULL了,插入新节点
        if (key < parent->_key)
        {
            parent->_left = new Node(key);
        }
        else
        {
            parent->_right = new Node(key);
        }
        return true;
    }

Find查找

    bool Find(const K& key)//非递归查找
    {
        if (_root == NULL) //空树直接返回
        {
            return false;
        }
        //非空树
        Node* cur = _root:
        while (cur)
        {
            if (key > cur->_key) //key值大 往右子树找
            {
                cur = cur->_right;
            }
            else if (key < cur->_key) //反之 左子树
            {
                cur = cur->_left;
            }
            else  //找到了返回真
            {
                return true;
            }
        }
        return false; //遍历之后发现并不存在
    }

Remove删除


    bool Remove(const K& key)//非递归删除
    {
        if (_root == NULL)
        {
            return false;
        }
        Node* cur = _root;
        Node* parent = NULL;
        while (cur)
        {
            if (cur->_key > key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else if (cur->_key < key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else //找到了  分三种情况
            {
                if (cur->_left == NULL)//根的左为空
                {
                    if (parent == NULL)
                    {
                        _root = cur->_right;
                        delete cur;
                        return true;
                    }
                    else
                    {
                        Node* tmp = cur->_right;
                        if (parent->_left == cur)
                        {
                            parent->_left = tmp;
                        }
                        else if (parent->_right == cur)
                        {
                            parent->_right = tmp;
                        }
                        delete cur;
                        return true;
                    }

                }
                else if(cur->_right == NULL)
                {
                    Node* tmp = cur->_left;
                    if (parent->_left == cur)
                    {
                        parent->_left = tmp;
                    }
                    else if (parent->_right == cur)
                    {
                        parent->_right = tmp;
                    }
                    delete cur;
                    return true;
                }
                else//cur左右两个孩子均不为空
                {
                    parent = cur;
                    Node* subleft = cur->_right;//找右孩子的最左节点
                    while (subleft->_left)
                    {
                        parent = subleft;
                        subleft = subleft->_left;
                    }
                    cur->_key = subleft->_key;

                    if (parent->_left == subleft)
                    {
                        parent->_left = subleft->_right;
                    }
                    else if (parent ->_right == subleft)
                    {
                        parent->_right = subleft->_right;
                    }
                    delete subleft;
                    return true;
                }
            }
        }
        return false;
    }

二叉搜索树的退化和缺陷
-如果插入的数接近有序或者基本有序时，会成为一条单向单一的树，类似于链表
例如：{0，1，2，3，4，5，6，7，8，9}

这个时候它的时间复杂度为O（N），所以要考虑高度

附上详细代码

#pragma once

template<class K>
struct BinarySearchTreeNode
{
    K _key;
    BinarySearchTreeNode<K>* _left;
    BinarySearchTreeNode<K>* _right;
    BinarySearchTreeNode(const K& key)
        :_key(key)
        ,_left(NULL)
        ,_right(NULL)
    {}
};

template<class K>
class BSTree
{
    typedef BinarySearchTreeNode<K> Node;
public:
    BSTree() //无参构造
        :_root(NULL)
    {}
    BSTree(K* a, size_t n) //构造函数
    {
        _root = NULL;
        for (size_t i = 0; i < n; ++i)
        {
            InsertR(a[i]);
        }
    }
    ~BSTree()
    {}
    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 > parent->_key)
            {
                cur = parent->_right;
            }
            else if (key < parent->_key)
            {
                cur = parent->_left;
            }
            else
            {
                return false;
            }
        }
        //cur找到NULL了,插入新节点
        if (key < parent->_key)
        {
            parent->_left = new Node(key);
        }
        else
        {
            parent->_right = new Node(key);
        }
        return true;
    }
    bool Find(const K& key)//非递归查找
    {
        if (_root == NULL) //空树直接返回
        {
            return false;
        }
        //非空树
        Node* cur = _root:
        while (cur)
        {
            if (key > cur->_key) //key值大 往右子树找
            {
                cur = cur->_right;
            }
            else if (key < cur->_key) //反之 左子树
            {
                cur = cur->_left;
            }
            else  //找到了返回真
            {
                return true;
            }
        }
        return false; //遍历之后发现并不存在
    }
    bool Remove(const K& key)//非递归删除
    {
        if (_root == NULL)
        {
            return false;
        }
        Node* cur = _root;
        Node* parent = NULL;
        while (cur)
        {
            if (cur->_key > key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else if (cur->_key < key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else //找到了  分三种情况
            {
                if (cur->_left == NULL)//根的左为空
                {
                    if (parent == NULL)
                    {
                        _root = cur->_right;
                        delete cur;
                        return true;
                    }
                    else
                    {
                        Node* tmp = cur->_right;
                        if (parent->_left == cur)
                        {
                            parent->_left = tmp;
                        }
                        else if (parent->_right == cur)
                        {
                            parent->_right = tmp;
                        }
                        delete cur;
                        return true;
                    }

                }
                else if(cur->_right == NULL)
                {
                    Node* tmp = cur->_left;
                    if (parent->_left == cur)
                    {
                        parent->_left = tmp;
                    }
                    else if (parent->_right == cur)
                    {
                        parent->_right = tmp;
                    }
                    delete cur;
                    return true;
                }
                else//cur左右两个孩子均不为空
                {
                    parent = cur;
                    Node* subleft = cur->_right;//找右孩子的最左节点
                    while (subleft->_left)
                    {
                        parent = subleft;
                        subleft = subleft->_left;
                    }
                    cur->_key = subleft->_key;

                    if (parent->_left == subleft)
                    {
                        parent->_left = subleft->_right;
                    }
                    else if (parent ->_right == subleft)
                    {
                        parent->_right = subleft->_right;
                    }
                    delete subleft;
                    return true;
                }
            }
        }
        return false;
    }

    //bool Insert(const K& key) //递归插入
    //{
    //  return _InsertR(_root, key);
    //}
//  bool RemoveR(const K& key) //递归删除
//  {
//      return _RemoveR(_root, key);
//  }
    void Inorder()
    {
        _Inorder(_root);
        cout << endl;
    }
protected:
     bool _InsertR(Node*& root,const K& key)
    {
        if (root == NULL)
        {
            root = new Node(key);
        }
        else
        {
            if (key > root->_key)
            {
                return _InsertR(root->_right, key);
            }
            else 
            {
                return _InsertR(root->_left, key);
            }
        }
        return true;
    }
     bool _RemoveR(Node*& root, const K& key)
    {
         if (root == NULL)
         {
             return false;
         }
         else if (root->_key > key)
         {
             return _RemoveR(root->_left, key);
         }
         else if (root->_key < key)
         {
             return _RemoveR(root->_right, key);
         }
         else //刚好根节点就是要删除的节点，分三种情况
         {
             if (root->_left == NULL)  //根节点左为空
             {
                 root = root->_right;
             }
             if (root->_right == NULL)  //根节点右为空
             {
                 root = root->_left;
             }
             else if //根节点左右都不为空，找替代节点
             {
                 Node* parent = root;
                 Node* subleft = root->right;  
                 while (subleft->_left)//右子树最左节点
                 {
                     root->key = subleft->key;
                     subleft = subleft->left;
                 }
             }
         }
    }

     void _Inorder(Node* root)
     {
         if (root == NULL)
         {
             return;
         }
         _Inorder(root->_left);
         cout << root->_key << " ";
         _Inorder(root->_right);
     }
protected:
    Node* _root;

};




void TestBSTree()
{
    int a[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 };
    BSTree<int> t1;
    for (size_t i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
    {
        t1.Insert(a[i]);
    }
    t1.Inorder();
    t1.Remove(1);   
    t1.Inorder();
    t1.Remove(0);
    t1.Inorder();
    t1.Remove(9);
    t1.Inorder();
    t1.Remove(5);
    t1.Inorder();
    t1.Remove(2);
    t1.Inorder();
    t1.Remove(3);
    t1.Inorder();
    t1.Remove(4);
    t1.Inorder();
    t1.Remove(6);   
    t1.Inorder();
    t1.Remove(7);
    t1.Inorder();
    t1.Remove(8);
    t1.Inorder();
}
Ruina_bai
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构：二叉搜索树的增删查改
BudingCode的博客
03-29 1352
二叉查找树的增删查改
二叉搜索树的增、删、查
就这样吧
05-20 301
二叉搜索树一、 什么是二叉搜索树？二、二叉搜索树查找value为key节点三、二叉搜索树增加value为key的节点四、二叉搜索树删除value为key的节点(替罪羊删除法)五、总结 一、 什么是二叉搜索树？ 二叉搜索树又称二叉排序树或是二叉查找树，关于它的定义： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 二、二叉搜索树查找value为key节点 二叉搜索树的查找是比较方便的，每次都能排除一半的
详解二叉搜索树的增删改查
qq_52906742的博客
08-15 796
二叉查找树（英语：Binary Search Tree），也称为二叉搜索树、有序二叉树（ordered binary tree）或排序二叉树（sorted binary tree），是指一棵空树或者具有下列性质的二叉树：二叉查找树相比于其他数据结构的优势在于查找、插入的时间复杂度较低。为。二叉查找树是基础性数据结构，用于构建更为抽象的数据结构，如集合、多重集、关联数组等。2.1 搜索树的节点二叉搜索树节点通常采用的是二叉链结构，就是一个指针指向左孩子一个指针指向右孩子。 2.2 构建树的结构 三、二叉搜索
二叉搜索树的增删改查
weixin_46028606的博客
08-01 274
#pragma once #include<iostream> using namespace std; class Tree { private: struct Node { int data; Node* left; Node* right; Node(int value=0):data(value),left(nullptr),right(nullptr){} }; Node* root; void insert(int key, Node*& o);//插
二叉排序树增删改查
02-19
ios编程：实现二叉排序树增删改查。 开发环境：windows下codeblocks。
C#二叉搜索树插入算法实例分析
01-21
本文实例讲述了C#二叉搜索树插入算法。分享给大家供大家参考。具体实现方法如下： public class BinaryTreeNode { public BinaryTreeNode Left { get; set; } public BinaryTreeNode Right { get; set; } public...
二叉搜索树实例练习
09-05
一棵二叉查找树是按二叉树结构来组织的。这样的树可以用链表结构表示，其中每一个结点都是一个对象
Python实现二叉搜索树
12-24
二叉搜索树 我们已经知道了在一个集合中获取键值对的两种不同的方法。回忆一下这些集合是如何实现ADT（抽象数据类型）MAP的。我们讨论两种ADT MAP的实现方式，基于列表的二分查找和哈希表。在这一节中，我们将要...
树-98. 验证二叉搜索树-PYTHON
01-20
递归 # Definition for a binary tree node. # class TreeNode(object): # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution(object): def isValidBST(self, root): ...
二叉搜索树的增删查改
qingqiulengya的博客
06-17 425
二叉搜索树注重增删查改，现在针对key/value形式进行研究。 现在对其进行实现，分别有插入，查找，删除，分别对这几个功能用递归和非递归实现。          其中删除操作比较特别，分为3种,分别是删除叶子节点，删除左为空或右为空的节点，第三种是删除左右子树都不为空的节点。最后一种删除最麻烦，它分为三个步骤，分别是找出右树的最左节点，然后和要删除的节点进行key/value的互换，然
b+树的增删改查_二叉搜索树相关题目的一些思路
weixin_39531635的博客
11-24 61
二叉搜索树的概念：若它的左子树不空，则左子树上所有结点的值均小于等于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于等于它的根结点的值。任意结点的左、右子树也分别为二叉搜索树。由上可知，二叉搜索树中序遍历结果是递增的。依据上面的概念，那如何构建一颗二叉搜索树呢？确定一个根结点，然后递归去构建其左右子树。// build(1, n); // [1, n] 下面重点讲讲几道leetco...
算法-二叉搜索树的完全实现“增删改查”(C++)
BLOG OF PETERMAOSX.
08-17 523
这是完整的代码，其他分功能的叙述在其他文章里 // // BST.cpp // algorithm // // Created by Mao on 2019/8/14. // Copyright © 2019 Mao. All rights reserved. // //实现二分搜索树 #include <stdio.h> #include <iostream> ...
二叉搜索树Java实现（增删改查遍历等操作）
Vincent
03-11 3498
是一种特殊结构的二叉树二叉排序树（BinarySortTree），又称二叉查找树、二叉搜索树。二叉搜索树需满足以下四个条件： 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 任意节点的左、右子树也分别为二叉查找树； 没有键值相等的节点。 二叉排序树性质按中序遍历二叉排序树，所得到的中序遍历序列是一个递增有序序
二叉搜索树的相关操作（增删查改）---非递归实现
better12038的博客
12-27 193
//BSTree.h //非递归实现 #pragma once #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;windows.h&gt; typedef struct BSTreeNode { int key; struct BSTreeNode *left; struct BSTreeNode *rig...
二叉搜索树(BST)的增删改
wuhengde的专栏
04-12 766
维基百科关于二叉搜索树的介绍二叉查找树（英语：Binary Search Tree），也称二叉搜索树、有序二叉树（英语：ordered binary tree），排序二叉树（英语：sorted binary tree），是指一棵空树或者具有下列性质的二叉树。在二叉查找树删去一个结点，分三种情况讨论：若*p结点为叶子结点，即PL（左子树）和PR（右子树）均为空树。由于删去叶子结点不破坏整棵树的结构，...
二叉搜索树的增删查
didi1663478999的博客
09-30 292
二叉搜索树的查找： Node* Find(const T& data) { Node* pcur = _proot; while (pcur) { if (data == pcur->_data) return pcur; else if (data < pcur->_data) pcur = pcur->_pleft; ...
二叉搜索树 增删查操作
e我所欲也的博客
06-13 513
文章目录二叉搜索树二叉搜索树的实现增（插入）操作查找操作删除操作改？二叉搜索树的应用 前言： 在现在数据为王的时代，数据的存储量一般都是很大的，为了在大量信息中找到某些值，就需要用到查找技术，为了提高查找效率，需要对数据进行排序。排序和查找的数据处理量几乎是整个数据处理量的80%，故排序和查找的有效性直接影响到基本算法的有效性。因而查找和排序是十分重要的处理技术。 往期基于线性表的排序方法--------》八大排序C语言实现版本 而基于线性表的查找方法一般分为： 顺序查找和二分查找。 接着便是学习基于树结
C++二叉查找树增删改查功能实现
chenyr0021
03-11 1111
二叉查找树是二叉树中的一个特例，其中序遍历结果是从小到大的。 由于二叉树的特殊结构，其增删改查功能都是可以用递归实现的。 代码如下： //tree.h #include &lt;iostream&gt; using namespace std; //结构体定义 typedef struct BST { int data; BST* leftChild;//左子节点 BST* rightCh...
c++二叉查找树增删查改
最新发布
11-11
以下是C++实现二叉搜索树的增删查改的示例代码： 1. 结点类的实现： ```c++ class Node { public: int val; Node* left; Node* right; Node(int val) { this->val = val; this->left = nullptr; this->...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值