请回答数据结构【二叉搜索树】

已于 2022-05-07 14:54:54 修改
阅读量767 收藏
点赞数 3
分类专栏： 高阶数据结构 文章标签： 数据结构 c++ 经验分享 二叉树 算法
于 2022-04-26 19:51:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Allen9012/article/details/124435568
版权

BingWallpaper25

请回答数据结构【二叉搜索树】

image-20220426194527035

1. BinarySearchTree（二叉排序树）

1.0 Intro

二叉搜索树也是一种树形结构，map和set的特性就需要用到二叉搜索树

搜索二叉树的增删查改时间复杂度是O(N)

1.1 concept

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:

🌸 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值

🌸 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值

🌸 它的左右子树也分别为二叉搜索树

picture is from https://faun.pub/introduction-to-binary-search-trees-8e225aca7037

2. 二叉搜索树快速入门

2.1 查找

最坏查找高度次，就可以确认一个值在不在树中

查找时间复杂度O(N)

极端：单支

image-20220422144357307

所以实际使用中一般还是没办法保证极度情况下的效率

于是人们在搜索二叉树的特性上扩展延申，产生了：AVLTree和红黑树

这些树堆左右高度有所要求，非常接近完全二叉树，他们的效率可以达到O(logN),

如果不是对于内存查找有所要求的话，有时候还会对磁盘查找有所要求，于是我们对树的高度又提出要求进而衍生出了B树系列，适合于外查找存储

2.2 BSTree应用

🍁 K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。

🍁 KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。

3. 实现二叉搜索树

3.0 搜索二叉树节点

如果你要把他叫成搜索二叉树的话你可以把结构typedef成SBTree，但是属实是不太好

我们通过用struct构造一个Node，然后封装入BSTree中，为了方便，将BSTreeNode<K> typedef 成 Node

template<class K>
struct BSTreeNode
{
	//字段
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	K _key;

	//构造
	BSTreeNode(const K& key)
		: _left(nullptr)
		, _right(nullptr)
		, _key(key)
	{}
};

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	BSTree()
		:_root(nullptr)
	{}
}；

3.1 Insert

下面来实现插入，插入的话显示遍历，找到插入位置，然后链接cur节点它不是很难

bool Insert(const K& key)
{
    if (_root == nullptr)
    {
        _root = new Node(key);
        return true;
    }
    else
    {
        //非递归
        Node* cur = _root;
        Node* parent = nullptr;
        //1. 遍历到底
        while (cur)
        {//插入一个值之后还要来链接节点，链接父亲
            if (cur->_key < key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_key > key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else//相等  ->  return false
                return false;
        }
        //2. 链接cur节点
        cur = new Node(key);
        if (parent->_key<key)
        {
            parent->_right = cur;
        }
        else
        {
            parent->_left = cur;
        }
        return true;
    }
}

3.2 InOder

这里选择中序遍历的原因是可以在输出的时候保证数据大小是有规律的，毕竟有着搜索二叉树的特性，就是左子树<根节点<右子树

这里的InOder为了防止传参要传根节点参数，我们可以封装一下，这样就不用传参了

void _InOrder(Node* root)
{
    if (root == nullptr)
        return;

    _InOrder(root->_left);
    cout << root->_key << " ";
    _InOrder(root->_right);
}
//防止传参要传根节点，我们可以封装一下
void InOder()
{
    _InOrder(_root);
}

3.3 Find

查找，很简单

Node* Find(const K& key)
{
    Node* cur = _root;
    while (cur)
    {
        if (cur->_key < key)
            cur = cur->_right;
        else if (cur->_key>key)
            cur = cur->_left;
        else
            return cur;
    }
    return nullptr;
}

3.4 Erase

3.4.1 抽丝剥茧

删除一个节点不管怎样删除完了一定还要保证是搜索二叉树就是宗旨

binary search

🍒 1. 如果要删除的是 1 5 7 11 的话其实相对好处理，特征是叶子节点
🌸 注意父亲节点的left或者tight也要置空，因为我们不想要野指针

image-20220423152951086

🍒 2. 如果是如果要删除的节点是 3 9 就相对麻烦一点，特征是：只有一个孩子
🌸 那我删除完之后交给父亲管理就可以了，然后父亲只要把指向自己位置的指针顶替即可

image-20220423153233753

🍒 3. 如果要删除的是当前情况下的 3 6 9 就不好处理了，特征是：有两个孩子
🌸 解决方案就是替换删除，从孩子中找一个能够替换自己的节点，替换删除，只有比左边大比右边小才可以，那么这个孩子怎么找？
🌿 左子树的最大节点，左子树最右节点就是最大的
🌿 右子树的最小节点，右子树最左节点就是最小的
🍁 这两个节点去替换后，都符合特征2或特征1的可以直接删除

满足特征1,我要删除6
image-20220423160228657
满足特征2,我要删除11image-20220423160551694

继续分析,特征1的其实可以当成特征2去处理,简化一点

3.4.2 躬行实践

下面来仔细分析删除,同样的还是要定义父亲指针和孩子指针

当找到要删除的节点,然后开始判断

  1. 如果当前节点右孩子为空

image-20220423202308213

else if (cur->_right == nullptr)
    {
        if (parent->_left == cur)
        {//我是父亲的左
            parent->_left = cur->_left;
        }
        else
        {//我是父亲的右
            parent->_right = cur->_left;
        }
        delete cur;
    }
  1. 如果当前节点的左孩子为空

和上图同理

if (cur->_left==nullptr)
    {//父亲指向cur的右
        if (parent->_left == cur)
        {//我是父亲的左
            parent->_left = cur->_right;
        } 
        else
        {//我是父亲的右
            parent->_right = cur->_right;
        }
        delete cur;//置空节点
    }
  1. 两个孩子，替换法删除(难点)

我们假设采取右树的最左节点来替换（也可以左树的最右节点）

image-20220423202725539

else
    //两个孩子，替换法删除
{
    Node* min_parent = nullptr;
    Node* minRight = cur->_right;
    //找到右树的最左节点
    while (minRight->_left)
    {
        min_parent = minRight;
        minRight = minRight->_left;
    }
    //保存替换的节点
    cur->_key = minRight->_key;
    //删除替换节点
    min_parent->_left = minRight->_right;
    delete minRight;
}

还有问题存在，极端情况下，如果我要删除的是下面的7的话

image-20220423211218194

else
    //两个孩子，替换法删除
{
    Node* min_parent = cur;
    Node* minRight = cur->_right;
    //找到右树的最左节点
    while (minRight->_left)
    {
        min_parent = minRight;
        minRight = minRight->_left;
    }
    //保存替换的节点
    cur->_key = minRight->_key;
    //删除替换节点
    if (min_parent->_left == minRight)
        min_parent->_left = minRight->_right;
    else
        min_parent->_right = minRight->_right;
    delete minRight;
}
3.4.3 化茧成蝶
bool Erase(const K& key)
{
    Node* parent = nullptr;
    Node* cur = _root;
    //1. 开始找
    while (cur)
    {
        if (cur->_key< key)
        {
            parent = cur;
            cur = cur->_right;
        }
        else if (cur->_key > key)
        {
            parent = cur;
            cur = cur->_left;
        }
        else
        {//2. 找到了,准备开始删除
            //左为空，右为空，都可以，把孩子交给父亲管理
            if (cur->_left==nullptr)
            {//父亲指向cur的右
                if (parent->_left == cur)
                {//我是父亲的左
                    parent->_left = cur->_right;
                } 
                else
                {//我是父亲的右
                    parent->_right = cur->_right;
                }
                delete cur;//置空节点
            }
            else if (cur->_right == nullptr)
            {
                if (parent->_left == cur)
                {//我是父亲的左
                    parent->_left = cur->_left;
                }
                else
                {//我是父亲的右
                    parent->_right = cur->_left;
                }
                delete cur;
            }
            else
                //两个孩子，替换法删除
            {
                Node* min_parent = cur;
                Node* minRight = cur->_right;
                //找到右树的最左节点
                while (minRight->_left)
                {
                    min_parent = minRight;
                    minRight = minRight->_left;
                }
                //保存替换的节点
                cur->_key = minRight->_key;
                //删除替换节点
                if (min_parent->_left == minRight)
                    min_parent->_left = minRight->_right;
                else
                    min_parent->_right = minRight->_right;
                delete minRight;
            }
            return true;
        }
    }
    return false;
}
3.4.4 精益求精

完了吗，就这样吗，太麻烦了，还可以改简单一点，为什么不复用呢？当然复用的话会慢一点，因为要再查找一次

else
    //两个孩子，替换法删除
{

    //找到右树的最左节点
    Node* minRight = cur->_right;
    while (minRight->_left)
    {
        minRight = minRight->_left;
    }
    K min = minRight->_key;
    //递归去删除替换节点，一定会走到作为空的情况处理
    this->Erase(min);
    cur->_key = min;//先删除再替换
}

还有就是发现删光树的时候崩掉了，说明还有问题

image-20220423214153786

bool Erase(const K& key)
{
    Node* parent = nullptr;
    Node* cur = _root;
    //1. 开始找
    while (cur)
    {
        if (cur->_key< key)
        {
            parent = cur;
            cur = cur->_right;
        }
        else if (cur->_key > key)
        {
            parent = cur;
            cur = cur->_left;
        }
        else
        {//2. 找到了,准备开始删除
            //左为空，右为空，都可以，把孩子交给父亲管理
            if (cur->_left==nullptr)
            {
                //如果cur没有父亲
                if (cur == _root)
                {
                    _root = cur->_right;
                }
                else
                {
                    //父亲指向cur的右
                    if (parent->_left == cur)
                    {//我是父亲的左
                        parent->_left = cur->_right;
                    }
                    else
                    {//我是父亲的右
                        parent->_right = cur->_right;
                    }
                }
                delete cur;//置空节点
            }
            else if (cur->_right == nullptr)
            {
                if (cur == _root)
                {
                    _root = cur->_left;
                } 
                else
                {
                    if (parent->_left == cur)
                    {//我是父亲的左
                        parent->_left = cur->_left;
                    }
                    else
                    {//我是父亲的右
                        parent->_right = cur->_left;
                    }
                }
                delete cur;
            }
            else
                //两个孩子，替换法删除
            {
                Node* minRight = cur->_right;
                while (minRight->_left)
                {
                    minRight = minRight->_left;
                }
                K min = minRight->_key;
                //递归去删除替换节点，一定会走到作为空的情况处理
                this->Erase(min);
                cur->_key = min;//先删除再替换
            }
            return true;
        }
    }
    return false;
}

4. 递归版搜索二叉树

之前的是非递归版搜索二叉树，现在来写一下递归版本的，为了控制递归的参数，我们采用了函数封装一个多参数版的递归用_函数,并将其放到了private中私有化，不让其他人调用

4.1 _FindR

private:	
    Node* _FindR(Node* root, const K& key)
    {
        //如果为空
        if (root==nullptr)
            return nullptr;

        //如果不为空
        if (root->_key>key)
            return _FindR(root->_left,key);
        else if(root->_key<key)
            return _FindR(root->_right,key);
        else
            return _root;
    }
public:
    Node* FindR(const K& key)
    {//为了递归保证参数
        return _FindR(_root, key);
    }

4.2 InsertR

插入的时候需要我们的思考，究竟什么时候我们怎么把要插入节点的父亲和孩子连上

其实很简单一个操作就可以解决了，就是把参数写成Node*& root，看看引用的效果

image-20220424202329767

private:
    bool _InsertR(Node*& root, const K& key)
		{
			if (root== nullptr)   //插入
			{
				root = new Node(key);
				return true;
			}

			if (root->_key>key)
			{
				return _InsertR(root->_left,key);
			} 
			else if (root->_key<key)
			{
				return _InsertR(root->_right,key);
			}
			else
			{
				return false;
			}
		}
		
public:
    bool InsertR(const K& key)
    {
        return _InsertR(root, key);
    }

4.3 EraseR

先去找要删除的节点

//找不到返回false
if (root==nullptr)
    return  false;

//寻找该节点
if (root->_key < key)
    return _EraseR(root->_right, key);
else if (root->_key > key)
    return _EraseR(root->_left, key);
else{}

找到之后开始删除，删除之前保存一下指针，指向原来的root，然后就可以delete了

//找到了,要删除root
if (root->_left==nullptr)
{//左树空，右树存在
    Node* del = root;//当下要删除的保存一下过会删除
    root = root->_right;//找到删掉节点的右孩子
    delete del;//删除节点
} 
else if(root->_right==nullptr)
{//右树空，左树存在
    Node* del = root;
    root = root->_left;
    delete del;
}

对于两个孩子的情况，替代法的话是用不上别名的，无法借助别名的话， 可以去最朴素的方法去删除，就还是原来非递归的写法
也可以用复用法，这里提供一下复用法

else
{//两孩子都存在,找右树的最左子代
    Node* minRight = root->_right;
    while (minRight->_left)
    {
        minRight = minRight->_left;
    }
    K min = minRight->_key;

    // 转换成在root的右子树删除min
    _EraseR(root->_right, min);
    root->_key = min;
}

那么整体来就是

bool _EraseR(Node*& root, const K& key)
{
    if (root==nullptr)
        return  false;

    //寻找该节点
    if (root->_key < key)
        return _EraseR(root->_right, key);
    else if (root->_key > key)
        return _EraseR(root->_left, key);
    else
    {//找到了,要删除root
        if (root->_left==nullptr)
        {//左树空，右树存在
            Node* del = root;//当下要删除的保存一下过会删除
            root = root->_right;//找到删掉节点的右孩子
            delete del;//删除节点
        } 
        else if(root->_right==nullptr)
        {//右树空，左树存在
            Node* del = root;
            root = root->_left;
            delete del;
        }
        else
        {//两孩子都存在,找右树的最左子代
            Node* minRight = root->_right;
            while (minRight->_left)
            {
                minRight = minRight->_left;
            }
            K  min = minRight->_key;

            // 转换成在root的右子树删除min
            _EraseR(root->_right, min);
            root->_key = min;
        }
        return true;
    }
}

5. 深浅拷贝

5.1 析构函数

private:
    //封装析构
    void _Destroy(Node* root)
    {//后序遍历析构
        if (root==nullptr)
            return;
        _Destroy(root->_left);
        _Destroy(root->_right);
        delete root;
    }
public:
    ~BSTree()
    {
        _Destroy(_root);
        _root = nullptr;
    }

5.2 拷贝构造

private:
    Node* _Copy(Node* root)
    {
        if (root==nullptr)
        {
            return nullptr;
        }
        Node* copyNode = new Node(root->_key);
        copyNode->_left = _Copy(root->_left);
        copyNode->_right = _Copy(root->_right);
        return copyNode;
    }
public:
	BSTree(const BSTree<K>& tree)
    {
        //递归拷贝
        _root=_Copy(tree._root);
    }

5.3 赋值运算符（现代）

//赋值运算符
//t1=t2
BSTree<K>& operator=(BSTree<K> tree)
{
    swap(_root, tree._root);
    return *this;
}

6. key-value 搜索二叉树

6.0 BSTreeNode

template<class K,class V>
struct BSTreeNode
{
    BSTreeNode<K,V>* _left;
    BSTreeNode<K,V>* _right;

    K _key;
    V _value;

    BSTreeNode(const K& key, const V& value)
        : _left(nullptr)
        , _right(nullptr)
        , _key(key)
        , _value(value);
    {}
};

6.1 替换成k-v

template<class K,class V>
class BSTree
{
    typedef BSTreeNode<K,V> Node;
    //下面的有些封装的函数可以放在私有的， 别人最好无法调用
private:

    //封装析构
    void _Destroy(Node* root )
    {//后序遍历析构
        if (root == nullptr)
            return;
        _Destroy(root->_left);
        _Destroy(root->_right);
        delete root;
    }

    //封装拷贝构造
    Node* _Copy(Node* root)
    {
        if (root == nullptr)
            return nullptr;

        Node* copyNode = new Node(root->_key);
        copyNode->_left = _Copy(root->_left);
        copyNode->_right = _Copy(root->_right);

        return copyNode;
    }

    Node* _FindR(Node* root, const K& key)
    {
        //如果为空
        if (root == nullptr)
            return nullptr;

        //如果不为空
        if (root->_key > key)
            return _FindR(root->_left, key);
        else if (root->_key < key)
            return _FindR(root->_right, key);
        else
            return _root;
    }

    //不许相同节点
    bool _InsertR(Node*& root, const K& key, const V& value)
    {
        if (root == nullptr)   //插入
        {
            root = new Node(key,value);
            return true;
        }

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

    bool _EraseR(Node*& root, const K& key)
    {
        if (root == nullptr)
            return  false;

        //寻找该节点
        if (root->_key < key)
            return _EraseR(root->_right, key);
        else if (root->_key > key)
            return _EraseR(root->_left, key);
        else
        {//找到了,要删除root
            if (root->_left == nullptr)
            {//左树空，右树存在
                Node* del = root;//当下要删除的保存一下过会删除
                root = root->_right;//找到删掉节点的右孩子
                delete del;//删除节点
            }
            else if (root->_right == nullptr)
            {//右树空，左树存在
                Node* del = root;
                root = root->_left;
                delete del;
            }
            else
            {//两孩子都存在,找右树的最左子代
                Node* minRight = root->_right;
                while (minRight->_left)
                {
                    minRight = minRight->_left;
                }
                K  k_min = minRight->_key;
                V v_min = minRight->_value;

                // 转换成在root的右子树删除min
                _EraseR(root->_right, k_min);
                root->_key = k_min;
                root->_value = v_min;
            }
            return true;
        }
    }

public:
    BSTree()
        :_root(nullptr)
    {}

    //析构
    ~BSTree()
    {
        _Destroy(_root);
        _root = nullptr;
    }

    //拷贝构造
    BSTree(const BSTree<K,V>& tree)
    {
        //递归拷贝
        _root = _Copy(tree._root);
    }

    //赋值运算符
    //t1=t2
    BSTree<K,V>& operator=(BSTree<K,V> tree)
    {
        swap(_root, tree._root);
        return *this;
    }

    bool InsertR(const K& key,const V& value)
    {
        return _InsertR(_root, key,value);
    }

    Node* FindR(const K& key)
    {//为了递归保证参数
        return _FindR(_root, key);
    }

    bool EraseR(const K& key)
    {
        return _EraseR(_root, key);
    }

    void _InOrder(Node* root)
    {
        if (root == nullptr)
            return;

        _InOrder(root->_left);
        cout << root->_key << " : " << root->_value << endl;
        _InOrder(root->_right);
    }

    void InOrder()
    {
        _InOrder(_root);
        cout << endl;
    }

private:
    Node* _root;
};

有关代码放到代码仓库了https://github.com/Allen9012/cpp/tree/main/C%2B%2B%E8%BF%9B%E9%98%B6/BSTree
后序会更一些有关二叉树的OJ题

言之命至9012
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二叉搜索树
sinat_40408114的博客
08-13 362
二叉搜索树 二叉搜索树是一颗二叉树，可能为空。一棵非空的二叉搜索树满足以下特征: 1).每个元素有一个关键字，并且任意两个元素的关键字都不同；因此，所有的关键字都是唯一的(如果有重复的话，这样的二叉树称为有重复的二叉搜索树)。 2).在根节点的左子树中，元素的关键字(如果有的话)都小于根节点的关键字。 3).在根节点的右子树中，元素的关键字(如果有的话)都大于根节点的关键字。 4).根节点的左右子...
数据结构资料
07-30
平衡二叉树是一类特殊的二叉搜索树，它的左右两个子树的高度差不超过1，并且左子树和右子树都是平衡二叉树。常见的平衡二叉树有AVL树和红黑树。这类树保持了二叉搜索树的特性，同时通过平衡条件保证了查找、插入和...
动态展示二叉搜索树之实践进行时
不忘初心，护天下安全！
11-12 1027
目录 一、选题展示 二、思考题目 三、阶段一：图形显示二叉搜索树之插入 1.图形显示二叉搜索树的要求 2.原博主的代码和输出 四、阶段二：图形显示二叉搜索树之查删 1.二叉搜索树的查找操作 2.二叉搜索树的删除操作 五、阶段三：动态显示二叉搜索树 六、阶段四：加入调整规则使二叉搜索树变为平衡树 七、阶段五：动态显示二叉平衡树 八、阶段六：使用多种方式显示二叉平衡树 1.j...
数据结构之二叉搜索树
野心与梦
04-19 1万+
*** 节点// 红黑树颜色 public int weight;//表示是频率(权重),哈夫曼树 public T data;} // 用于节点的层数 public int getNodeDepth(BinaryNode root) {} /*** 查找后继节点* @return// 查找node的后继节点 if(this . right == null) {// 表示没有右边 那就没有后继 return this;
数据结构和算法（十一）之二叉搜索树
yige001的博客
04-19 345
数据结构和算法（十一）之二叉搜索树 一. 二叉搜索树的概念 我们先来简单理解一下什么是二叉搜索树. 什么是二叉搜索树? 二叉搜索树（BST，Binary Search Tree），也称二叉排序树或二叉查找树 二叉搜索树是一颗二叉树, 可以为空；如果不为空，满足以下性质： 非空左子树的所有键值小于其根结点的键值。 非空右子树的所有键值大于其根结点的键值。 左、右子树本身也都是二叉搜索树。 下面哪些是二叉搜索树, 哪些不是? 二叉搜索树的特点: 二叉搜索树的特点就是相对较小的值总是保
数据结构-二叉排序树（图文详细版）
热门推荐
淡沫初夏zz的博客
01-17 5万+
二叉排序树
数据结构(js实现)——图解二叉搜索树
M_Edison的博客
03-10 705
文章目录1.概念2.二叉搜索树的封装以及常见操作3.插入操作的封装4.三种遍历方式封装4.1 先序遍历4.2 中序遍历4.3 后序遍历5.获取最大值和最小值6.搜索特定的值7.删除操作7.1 结点是叶子节点（没有子节点）7.2 删除的结点有一个子节点7.3 删除的结点有两个子节点8.结语 1.概念 二叉搜索树（BST），又称二叉排序树和二叉查找树。 二叉搜索树是一颗二叉树，可以为空，如果不为空，则满足以下三个条件： 非空左子树的所有键值小于根节点的键值 非空右子树的所有键值大于根节点的键值 左右子树本身
数据结构：JS实现二叉搜索树
鸭绒的博客
10-25 241
数据结构：二叉搜索树 前面, 我们学习了关于树的一些概念以及比较重要的二叉树的特性. 现在, 我们为二叉树再增加一个限制, 那么就可以形成一个二叉搜索树. 一. 二叉搜索树的概念 我们先来简单理解一下什么是二叉搜索树. 什么是二叉搜索树? 二叉搜索树（BST，Binary Search Tree），也称二叉排序树或二叉查找树 二叉搜索树是一颗二叉树, 可以为空；如果不为空，满足以下性质： 非空左子树的所有键值小于其根结点的键值。 非空右子树的所有键值大于其根结点的键值。 左、右子树本身也都是
【数据结构】简单实现一个二叉搜索树的基本功能（查找/插入/删除）
Superkom666的博客
11-04 331
二叉搜索树是一种经典的数据结构简单来说就是接下来就来用代码实现三个基本操作。
【数据结构】考点三十三 ：二叉排序树
超越的博客
04-29 767
二叉排序树（Binary Sort Tree），又称为二叉搜索树（Binary Search Tree），是一种特殊的二叉树。在二叉排序树中，对于每个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这样的性质使得二叉排序树在查找、插入和删除操作中具有高效的性能。
大学数据结构模拟试卷二
04-20
四、阅读算法回答问题部分涉及链表操作、数组处理、二叉搜索树构建和两序列合并： 1. 算法AA在单链表末尾添加新元素，实现了链表的尾插操作。 2. 算法BB是删除列表中连续重复的元素，使得列表中没有连续的相同元素。...
数据结构1800题包括完整答案.rar
10-30
同时，了解和实践这些答案也将帮助你在面试中自信地回答数据结构相关的问题，无论是笔试还是面试环节，都能展现出扎实的理论基础和实践经验。 总的来说，这份“数据结构1800题包括完整答案”的资源，是你提升数据...
大学数据结构课程模拟试卷一
04-20
以上内容详细解释了试卷中的关键知识点，包括线性表的插入操作、散列表的装填因子、B树的性质、稀疏矩阵的存储、图的最小生成树、快速排序的时间复杂度、二叉搜索树的查找规则、链表的反转、线性表的操作以及二叉树...
数据结构期末考试复习总结.doc
11-26
算法填空题可能涉及二叉搜索树的查找、插入或删除操作，这需要对二叉树的性质有深入理解。 在复习过程中，考生应重点掌握各种数据结构的特性、操作方法，以及常见算法的实现与效率分析。此外，理解和应用这些知识到...
计数，桶与基数排序
m0_68142120的博客
07-19 852
要进行 i(最高位的位数) 趟排序 ， 每趟排序需要将元素分派到k个桶，所以每趟排序的时间复杂度为O(n+k) 走i趟时间复杂度就为O(i(n+k)) 但桶的个数通常是固定的，执行的躺数一般又较小，所以基数排序的。如果待排序的元素数量很大，这可能会占用较多的内存空间。再次遍历待排序数组，对于数组中的每个元素，将其值减去最小值（为了使得计数数组的下标从0开始），并将计数数组中对应下标的值加1。如果待排序数组中的元素是负数，或者元素的取值范围较大，计数排序可能不适用，因为它需要额外的空间来存储计数数组。
数组算法--基本查找
最新发布
2303_78660417的博客
07-20 413
基本查找就是从数组的0索引处开始，依次往后查找，如果找到了对应索引处的值，就会，如果没有找到。因为数组的索引号是没有-1的，当返回-1的时候，就能明白没有找到。
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1094
可以参考以下视频。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 264
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
二叉搜索树和二叉查找树
07-28
回答: 二叉搜索树和二叉查找树是同一个概念，都是指一种特殊的二叉树结构，其中每个节点的值都大于其左子树中的所有节点的值，且小于其右子树中的所有节点的值。二叉搜索树的创建可以从空树开始，按照输入关键字的顺序依次进行插入操作，最终得到一棵二叉搜索树。\[1\]由于二叉搜索树的中序遍历有序性，即得到的递增的序列，因此可以利用二分查找的思想进行查找操作，每次都可以缩小查找范围，查询效率较高。\[2\]在删除操作中，如果被删除节点的左子树为空，则令其右子树代替其位置；如果被删除节点的右子树为空，则令其左子树代替其位置；如果被删除节点的左右子树都不为空，则可以选择其直接前驱或者直接后继代替它，再删除其直接前驱或者直接后继即可。\[3\] #### 引用[.reference_title] - *1* *2* *3* [【数据结构】二叉查找树（BST）](https://blog.csdn.net/m0_46628950/article/details/126768144)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

言之命至9012

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值