【基本数据结构】二叉查找树

已于 2024-06-17 16:29:39 修改
阅读量975 收藏 15
点赞数 8
分类专栏： 算法与数据结构 文章标签： 数据结构 二叉查找树 C++
于 2024-05-23 17:47:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54383080/article/details/139153629
版权

文章目录

二叉查找树也叫二叉搜索树，英文名为 Binary Search Tree，简称 BST。

前言

本系列专注更新基本数据结构，现有以下文章：

【算法与数据结构】数组.

【算法与数据结构】链表.

【算法与数据结构】哈希表.

【算法与数据结构】二叉查找树

【算法与数据结构】平衡二叉树

1 简介

对于一棵二叉树，如果树中的每个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值，且左右子树也分别是二叉查找树，那么该二叉树被称为二叉查找树。即同时满足以下三个条件的二叉树被称为二叉查找树。

  • 如果某二叉树有左子树，并且左子树中所有节点的值均小于其根节点的值；
  • 如果某二叉树有右子树，并且右子树中所有节点的值均大于其根节点的值；
  • 左右子树都是二叉查找树。

特殊的，空树也是二叉查找树。

2 基本实现

二叉查找树是一种集合了链表插入节点的灵活性与有序数组查找的高效性的数据结构。在链表中插入节点，我们只需遍历链表找到插入的指定位置，然后更改指针的指向即可，链表插入节点的最坏时间复杂度为 O ( n ) O(n) O(n)。在有序数组中，我们可以使用二分法快速定位到指定的元素。

在二叉查找树中，我们可以利用二叉查找树的特征二分查找指定的节点。基于这种二分查找，我们又可以快速定位到插入节点的指定位置。接下来就具体看看二叉查找树的查找、插入以及一些其他的基本操作。

2.1 数据表示

节点类

在介绍二叉查找树的基本操作之前，先来看一下二叉节点树中的节点类是如何定义的。

每个节点都包含一个值、一条左链接、一条右链接和一个节点计数器。左链接指向一棵由小于该节点的所有值组成的二叉查找树，右链接指向一棵由大于该节点的所有值组成的二叉查找树。节点计数器给出了以该节点为根的子树的总节点数。

struct Node {
    int val;
    Node* left;
    Node* right;
    int N;

    Node(): val(0), left(nullptr), right(nullptr) {}
    Node(int _val, int _N): val(_val), left(nullptr), right(nullptr), N(_N) {}
    Node(int _val ,Node* _left, Node* _right, int _N): val(_val), left(_left), right(_right), N(_N) {} 
};

二叉查找树类

二叉查找树中的成员函数比较多，公有成员是二叉查找树中函数的接口，而私有成员是具体的实现（私有类内声明，类外定义）。

接下来会针对每一个成员函数进行具体的讲解。

class BST {
private:
    Node* root;

    int size(Node* x);
    bool search(Node* x, int target);
    Node* put(Node* x, int val);
    Node* min(Node* x);
    Node* max(Node* x);
    void inOrder(Node* x);
    Node* floor(Node* x, int val);
    Node* ceil(Node* x, int val);
    Node* select(Node* x, int k);
    int rank(Node* x, int val);
    Node* deleteMin(Node* x);
    Node* deleteMax(Node* x);
    Node* deleteNode(Node* x, int val);
    void range(Node* x, queue<int>& que, int lo, int hi);
public:
    BST (): root(nullptr) {}

    // 获得二叉搜索树节点数的接口
    int getSize() {
        return size(root);
    }

    // 查找节点的接口
    bool getSearch(int target) {
        return search(root, target);
    }

    // 插入节点的接口
    void getPut(int val) {
        root = put(root, val);
    }

    // 获得节点最小值的接口
    int getMin() {
        return min(root)->val;
    }

    // 获得节点最小值的接口
    int getMax() {
        return max(root)->val;
    }

    // 输出二叉查找树的中序遍历结果
    void getInOrder() {
        inOrder(root);
    }

    // floor 的接口，不存在就返回 -1
    int getFloor(int val) {
        Node* x = floor(root, val);
        return x == nullptr ? -1 : x->val;
    }

    // ceil 的接口，不存在就返回 -1
    int getCeil(int val) {
        Node* x = ceil(root, val);
        return x == nullptr ? -1 : x->val;
    }

    // select 的接口，不存在就返回 -1
    int getSelect(int k) {
        Node* x = select(root, k);
        return x == nullptr ? -1 : x->val;
    }

    // rank 的接口
    int getRank(int val) {
        return rank(root, val);
    }

    // deleteMin 的接口
    void getDeleteMin() {
        root = deleteMin(root);
    }

    // deleteMax 的接口
    void getDeleteMax() {
        root = deleteMax(root);
    }

    // deleteNode 的接口
    void getDeleteNode(int val) {
        root = deleteNode(root, val);
    }

    // range 的接口
    queue<int> getRange(int lo, int hi) {
        queue<int> que;
        range(root, que, lo, hi);
        return que;
    }
};

2.2 查找

二叉查找树的查找功能具备二分查找的快速查找功能，在一次二分查找后查找区间就会缩减一半，随着我们不断在二叉查找树中向下查找，当前节点所表示的子树的大小也在减少，当查找命中（找到指定的节点值）或者未命中时查找过程才会停止。

二叉查找通常有两种实现方法：递归和迭代。

在递归查找中：

  • 如果树是空的，则查找未命中；
  • 如果被查找的值和根节点的值相等，则查找命中；
  • 否则，我们就递归的在左子树或右子树中查找。具体地，如果指定的节点值小于根节点值则在左子树中递归查找，否则在右子树中递归查找。

在迭代查找中：

  • 如果树是空的，则查找未命中；
  • 如果被查找的值和根节点的值相等，则查找命中；
  • 否则，我们就在左子树或右子树中迭代查找，如果指定的节点值小于根节点值则在左子树查找，否则在右子树中查找，直至查找命中或者未命中。

代码

// 查找节点的接口
bool getSearch(int target) {
    return search(root, target);
}

// 递归搜索节点，找到返回 true，否则返回 false
bool BST::search(Node* x, int target) {
    if (x == nullptr) {
        return false;
    }

    if (x->val == target) {
        return true;
    }
    else if (target < x->val) {
        return search(x->left, target);
    }
    else {
        return search(x->right, target);
    }
}

// 迭代查找
bool BST::search2(Node* x, int target) {
    Node* curr = x;
    while (curr != nullptr) {
        if (curr->val == traget) {
            return true;
        }
        else if (target < curr->val) {
			curr = curr->left;
        }
        else {
			curr = curr->right;
        }
    }
    return false;
}

getSearch 函数是供类对象调用的查找二叉树中是否存在指定节点值的函数接口，查找功能由 search 函数（递归）或 search2函数（迭代）具体实现。如果查找到指定节点值 target 则返回 true，否则返回 false。

注：下方的二叉查找树的所有实现均有接口和具体实现组成，以 get 开头的为接口函数。

2.3 插入

插入的递归实现与查找的递归实现很相似：如果树是空的，就返回一个含有插入值的节点；如果需要被插入的节点值小于根节点的值，我们就在左子树中递归的插入，否则就在右子树中递归的插入。

不同于查找代码的是，我们还需要自底向上更新每个节点的计数器。递归调用递的过程可以想象成沿着树向下走，根据需要插入的节点值与每个节点的值比较来确定是向左走还是向右走。递归调用的归的过程可以想象成沿着树往上爬。对于 查找 的方法，这对应着一系列的 返回指令，但是对于 插入 方法，这意味着重置搜索路径上每个父节点指向子节点的链接，并增加路径上每个节点中的计数器的值。

插入同样有递归和迭代两种实现方法。以下给出的是插入的递归实现，迭代实现可做练习。

代码

// 插入节点的接口
void getPut(int val) {
    root = put(root, val);
}

// 递归查找 val，找到则更新，否则创建节点
Node* BST::put(Node* x, int val) {
    if (x == nullptr) {
        return new Node(val, 1);
    }
    if (val < x->val) {
        x->left = put(x->left, val);
    }
    else if (val > x->val) {
        x->right = put(x->right, val);
    }
    else {
        x->val = val;
    }
    // 自下而上重置每一层节点的 N 值
    x->N = 1 + size(x->left) + size(x->right);
    return x;
}

3 有序性相关的方法和删除

3.1 查找最值

根据二叉查找树的定义与性质可知，二叉查找树中的最小值为最左侧叶子节点对应的值，最大值为最右侧叶子节点对应的值。因此，分别在二叉查找树的左子树和右子树中递归的查找即可找出树中节点的最小值和最大值。

代码

// 获得节点最小值的接口
int getMin() {
    return min(root)->val;
}

// 获得节点最大值的接口
int getMax() {
    return max(root)->val;
}

// 返回二叉查找树中节点值最小的节点
Node* BST::min(Node* x) { 
    if (x->left == nullptr) {
        return x;
    }
    return min(x->left);
}

// 返回二叉查找树中节点值最大的节点
Node* BST::max(Node* x) {
    if (x->right == nullptr) {
        return x;
    }
    return max(x->right);
}

3.2 向上取整/向下取整

对数 x 向上取整指的是返回大于或等于 x 最小的值，向下取整指的是返回小于或者等于 x 最大的值。

在二叉查找树中，我们也可以对某一个数进行取整操作。具体地，定义函数 getFloor(val) 表示在二叉查找书中返回小于或者等于 val 最大的值，即向下取整。定义函数 getCeil(val) 表示在二叉查找书中返回大于或者等于 val 最小的值，即向上取整。

如果给定的节点值 val 小于二叉查找树的根节点的值，那么小于或者等于 val 最大的值一定在根节点的左子树中；如果给定的节点值 val 大于二叉查找树根节点的值，那么只有当根节点右子树中存在小于等于 val 的节点时，小于等于 val 的最大值才会出现在右子树中。此段便是 floor 函数的逻辑。

将 “左” 变为 “右”，同时将小于变为大于就能得到 ceil 函数。

代码

// floor 的接口，不存在就返回 -1
int getFloor(int val) {
    Node* x = floor(root, val);
    return x == nullptr ? -1 : x->val;
}

// ceil 的接口，不存在就返回 -1
int getCeil(int val) {
    Node* x = ceil(root, val);
    return x == nullptr ? -1 : x->val;
}

// 向下取整，找出小于等于 val 的最大节点值
Node* BST::floor(Node* x, int val) {
    if (x == nullptr) {
        return nullptr;
    }

    if (x->val == val) {
        return x;
    }

    if (val < x->val) { 
        return floor(x->left, val);
    }

    Node* t = floor(x->right, val);
    return t != nullptr ? t : x;
}

// 向上取整，找出大于等于 val 的最小节点值
Node* BST::ceil(Node* x, int val) {
    if (x == nullptr) {
        return nullptr;
    }

    if (x->val == val) {
        return x;
    }

    if (val > x->val) {
        return ceil(x->right, val);
    }

    Node* t = ceil(x->left, val);
    return t != nullptr ? t : x;
}

3.3 选择操作

假设我们想找到排名为 k 的节点（即树中正好有 k 个小于它的节点值）：

  • 如果左子树中的节点数 t 大于 k，那么我们就继续递归地在左子树中查找排名为 k 的节点；
  • 如果 t 等于 k，我们就返回根节点；
  • 如果 t 大于 k，我们就递归地在右子树中查找排名为 t-k-1 的节点。

代码

// select 的接口，不存在就返回 -1
int getSelect(int k) {
    Node* x = select(root, k);
    return x == nullptr ? -1 : x->val;
}

// 选择操作：找到排名为 k 的节点（树中正好有 k 个小于它的节点值）
Node* BST::select(Node* x, int k) {
    if (x == nullptr) {
        return nullptr;
    }
    int t = size(x->left);
    if (t > k) {
        return select(x->left, k);
    }
    else if (t < k) {
        return select(x->right, k - t - 1);
    }
    else {
        return x;
    }
}

3.4 排名

排名操作和选择操作正相反，它会返回给定节点值的排名，在实现中：

  • 如果给定的节点值和根节点的值相等，我们返回左子树中的节点总数 t;
  • 如果给定的节点值小于根节点的值，我们会返回该节点值在左子树中的排名（递归计算）；
  • 如果给定的节点值大于根节点的值，我们会返回 t+1 加上它在右子树中的排名（递归计算）。

代码

// rank 的接口
int getRank(int val) {
    return rank(root, val);
}

// 排名操作：返回以 root 为根节点的子树中小于 val 的节点的数量
int BST::rank(Node* x, int val) {
    if (x == nullptr) {
        return 0;
    }

    if (val < x->val) {
        return rank(x->left, val);
    }
    else if (val > x->val) {
        return 1 + size(x->left) + rank(x->right, val);
    }
    else {
        return size(x->left);
    }
}

3.5 删除最值

二叉查找树中最难实现的也是比较重要的方法是删除方法。作为准备，我们先来实现删除最小节点值对应的节点。 我们定义函数 deleteMin 来删除最小节点值对应的节点，我们接收一个节点，最后返回删除 “最小” 节点后二叉查找树的新的头节点。

在实现中，我们要不断深入根节点的左子树直至遇到一个空节点，然后将指向该节点的链接指向该节点的链接指向该节点的右子树。结合代码仔细体会。

代码

// deleteMin 的接口
void getDeleteMin() {
    root = deleteMin(root);
}

// deleteMax 的接口
void getDeleteMax() {
    root = deleteMax(root);
}

// 删除最小值，返回删除后的二叉搜索树新的根节点
Node* BST::deleteMin(Node* x) {
    if (x->left == nullptr) {
        return x->right;
    }

    x->left = deleteMin(x->left);
    x->N = size(x->left) + size(x->right) + 1;
    return x;
}

// 删除最大值，返回删除后新的跟节点
Node* BST::deleteMax(Node* x) {
    if (x->right == nullptr) {
        return x->left;
    }

    x->right = deleteMax(x->right);
    x->N = size(x->left) + size(x->right) + 1;
    return x;
}

3.6 删除操作

我们可以用类似的方法删除任意只有一个子节点，或者没有子节点的节点，但是如何删除一个拥有两个子节点的节点呢？删除之后我们要处理两棵子树，但被删除节点的父节点只有一条空出来的链接。

T.Hibbard 在 1962 年提出了解决该问题的第一个方法，在删除节点 x 后用它的后继节点填补它的位置。因为 x 有一个右子节点，因此它的后继节点就是其右子树中的最小节点。这样的替换仍然能够保证数的有序性，因为节点 x 的值和它后继节点的值之间不存在其他的键。我们能够用 4 个简单的步骤完成 x 替换为它的后继节点的任务：

  • 将即将被删除的节点 x 保存到 t；
  • 将 x 指向它的后继节点中 min(t->right)；
  • 将 x 的右链接指向 deleteMin(t->right)，也就是删除后所有节点仍都大于 x->val 的子二叉树；
  • 将 x 的左链接设为 t->left。

代码

// deleteNode 的接口
void getDeleteNode(int val) {
    root = deleteNode(root, val);
}

// 删除指定节点并返回新的根节点
Node* BST::deleteNode(Node* x, int val) {
    if (x == nullptr) {
        return nullptr;
    }
    if (val < x->val) {
        x->left = deleteNode(x->left, val);
    }
    else if (val > x->val) {
        x->right = deleteNode(x->right, val);
    }
    else {
        if (x->left == nullptr) {
            return x->right;
        }
        if (x->right == nullptr) {
            return x->left;
        }
        
        Node* t = x;
        x = min(t->right);
        x->right = deleteMin(t->right);
        x->left = t->left;
    }
    x->N = 1 + size(x->left) + size(x->right);
    return x;
}

3.7 范围查找

二叉查找树最后一个常用操作是范围查找，不同于记录所有二叉树查找树的节点值，我们只需要将节点值在指定范围内的节点记录下来即可。

在具体实现中：

  • 如果当前节点值在范围内，直接记录到答案队列中；
  • 如果查找区间左端点落在根节点的左子树中，则在左子树中递归记录节点；
  • 如果查找区间右端点落在根节点的右子树中，则在右子树中递归记录节点。

代码

// range 的接口
queue<int> getRange(int lo, int hi) {
    queue<int> que;
    range(root, que, lo, hi);
    return que;
}

// 范围查找，返回二叉搜索树中在 [lo, hi] 范围内的节点值
void BST::range(Node* x, queue<int>& que, int lo, int hi) {
    if (x == nullptr) {
        return;
    }

    if (lo < x->val) {
        range(x->left, que, lo, hi);
    }
    if (lo <= x->val && hi >= x->val) {
        que.push(x->val);
    }
    if (hi > x->val) {
        range(x->right, que, lo, hi);
    }
}

有二叉查找树的定义可知，如果对二叉查找树进行中序遍历，那么将得到非递减的序列。中序遍历代码为：

void inorderTraversal(TreeNode* root) {
  if (root == nullptr) {
    return;
  }
  inorderTraversal(root->left);
  std::cout << root->key << " ";
  inorderTraversal(root->right);
}

4 手写二叉查找树

上文提到的二叉查找树所有实现的完整代码如下：

bst.hpp

#ifndef BST__H
#define BST__H

#include <queue>

using namespace std;

struct Node {
    int val;
    Node* left;
    Node* right;
    int N;

    Node(): val(0), left(nullptr), right(nullptr) {}
    Node(int _val, int _N): val(_val), left(nullptr), right(nullptr), N(_N) {}
    Node(int _val ,Node* _left, Node* _right, int _N): val(_val), left(_left), right(_right), N(_N) {} 
};

class BST {
private:
    Node* root;

    int size(Node* x);
    bool search(Node* x, int target);
    Node* put(Node* x, int val);
    Node* min(Node* x);
    Node* max(Node* x);
    void inOrder(Node* x);
    Node* floor(Node* x, int val);
    Node* ceil(Node* x, int val);
    Node* select(Node* x, int k);
    int rank(Node* x, int val);
    Node* deleteMin(Node* x);
    Node* deleteMax(Node* x);
    Node* deleteNode(Node* x, int val);
    void range(Node* x, std::queue<int>& que, int lo, int hi);
public:
    BST (): root(nullptr) {}

    // 获得二叉搜索树节点数的接口
    int getSize() {
        return size(root);
    }

    // 查找节点的接口
    bool getSearch(int target) {
        return search(root, target);
    }

    // 插入节点的接口
    void getPut(int val) {
        root = put(root, val);
    }

    // 获得节点最小值的接口
    int getMin() {
        return min(root)->val;
    }

    // 获得节点最大值的接口
    int getMax() {
        return max(root)->val;
    }

    // 输出二叉查找树的中序遍历结果
    void getInOrder() {
        inOrder(root);
    }

    // floor 的接口，不存在就返回 -1
    int getFloor(int val) {
        Node* x = floor(root, val);
        return x == nullptr ? -1 : x->val;
    }

    // ceil 的接口，不存在就返回 -1
    int getCeil(int val) {
        Node* x = ceil(root, val);
        return x == nullptr ? -1 : x->val;
    }

    // select 的接口，不存在就返回 -1
    int getSelect(int k) {
        Node* x = select(root, k);
        return x == nullptr ? -1 : x->val;
    }

    // rank 的接口
    int getRank(int val) {
        return rank(root, val);
    }

    // deleteMin 的接口
    void getDeleteMin() {
        root = deleteMin(root);
    }

    // deleteMax 的接口
    void getDeleteMax() {
        root = deleteMax(root);
    }

    // deleteNode 的接口
    void getDeleteNode(int val) {
        root = deleteNode(root, val);
    }

    // range 的接口
    queue<int> getRange(int lo, int hi) {
        queue<int> que;
        range(root, que, lo, hi);
        return que;
    }
};

#endif

bst.cpp

#include <iostream>

#include "bst.hpp"

using namespace std;

int BST::size(Node* x) {
    if (x == nullptr) {
        return 0;
    }
    return x->N;
};

// 递归搜索节点，找到返回 true，否则返回 false
bool BST::search(Node* x, int target) {
    if (x == nullptr) {
        return false;
    }

    if (x->val == target) {
        return true;
    }
    else if (target < x->val) {
        return search(x->left, target);
    }
    else {
        return search(x->right, target);
    }
}

// 递归查找 val，找到则更新，否则创建节点
Node* BST::put(Node* x, int val) {
    if (x == nullptr) {
        return new Node(val, 1);
    }
    if (val < x->val) {
        x->left = put(x->left, val);
    }
    else if (val > x->val) {
        x->right = put(x->right, val);
    }
    else {
        x->val = val;
    }
    // 自下而上重置每一层节点的 N 值
    x->N = 1 + size(x->left) + size(x->right);
    return x;
}

// 返回二叉查找树中节点值最小的节点
Node* BST::min(Node* x) { 
    if (x->left == nullptr) {
        return x;
    }
    return min(x->left);
}

// 返回二叉查找树中节点值最大的节点
Node* BST::max(Node* x) {
    if (x->right == nullptr) {
        return x;
    }
    return max(x->right);
}

// 二叉查找的中序遍历
void BST::inOrder(Node* x) {
    if (x == nullptr) {
        return;
    }
    inOrder(x->left);
    cout << x->val << endl;;
    inOrder(x->right);
}

// 向下取整，找出小于等于 val 的最大节点值
Node* BST::floor(Node* x, int val) {
    if (x == nullptr) {
        return nullptr;
    }

    if (x->val == val) {
        return x;
    }

    if (val < x->val) { 
        return floor(x->left, val);
    }

    Node* t = floor(x->right, val);
    return t != nullptr ? t : x;
}

// 向上取整，找出大于等于 val 的最小节点值
Node* BST::ceil(Node* x, int val) {
    if (x == nullptr) {
        return nullptr;
    }

    if (x->val == val) {
        return x;
    }

    if (val > x->val) {
        return ceil(x->right, val);
    }

    Node* t = ceil(x->left, val);
    return t != nullptr ? t : x;
}

// 选择操作：找到排名为 k 的节点（树中正好有 k 个小于它的节点值）
Node* BST::select(Node* x, int k) {
    if (x == nullptr) {
        return nullptr;
    }
    int t = size(x->left);
    if (t > k) {
        return select(x->left, k);
    }
    else if (t < k) {
        return select(x->right, k - t - 1);
    }
    else {
        return x;
    }
}

// 排名操作：返回以 root 为根节点的子树中小于 val 的节点的数量
int BST::rank(Node* x, int val) {
    if (x == nullptr) {
        return 0;
    }

    if (val < x->val) {
        return rank(x->left, val);
    }
    else if (val > x->val) {
        return 1 + size(x->left) + rank(x->right, val);
    }
    else {
        return size(x->left);
    }
}

// 删除最小值，返回删除后的二叉搜索树新的根节点
Node* BST::deleteMin(Node* x) {
    if (x->left == nullptr) {
        return x->right;
    }

    x->left = deleteMin(x->left);
    x->N = size(x->left) + size(x->right) + 1;
    return x;
}

// 删除最大值，返回删除后新的跟节点
Node* BST::deleteMax(Node* x) {
    if (x->right == nullptr) {
        return x->left;
    }

    x->right = deleteMax(x->right);
    x->N = size(x->left) + size(x->right) + 1;
    return x;
}

// 删除指定节点并返回新的根节点
Node* BST::deleteNode(Node* x, int val) {
    if (x == nullptr) {
        return nullptr;
    }
    if (val < x->val) {
        x->left = deleteNode(x->left, val);
    }
    else if (val > x->val) {
        x->right = deleteNode(x->right, val);
    }
    else {
        if (x->left == nullptr) {
            return x->right;
        }
        if (x->right == nullptr) {
            return x->left;
        }
        
        Node* t = x;
        x = min(t->right);
        x->right = deleteMin(t->right);
        x->left = t->left;
    }
    x->N = 1 + size(x->left) + size(x->right);
    return x;
}

// 范围查找，返回二叉搜索树中在 [lo, hi] 范围内的节点值
void BST::range(Node* x, queue<int>& que, int lo, int hi) {
    if (x == nullptr) {
        return;
    }

    if (lo < x->val) {
        range(x->left, que, lo, hi);
    }
    if (lo <= x->val && hi >= x->val) {
        que.push(x->val);
    }
    if (hi > x->val) {
        range(x->right, que, lo, hi);
    }
}

5 总结

二叉查找树是一种集合链表插入节点的灵活性与有序数组查找的高效性的数据结构。在上面分析的几种操作中，最重要的是查找、插入以及删除这三种操作。

查找操作的时间复杂度为 O ( l o g n ) O(logn) O(logn)， n n n 是二叉查找树中节点的数量。插入和删除的操作最坏情况是，二叉查找树退化成一条链，此时如果在链表的尾部插入元素或者删除链表尾部的元素，时间复杂度为 O ( n ) O(n) O(n)。

那能否有一种比二叉查找树中插入和删除操作更优的数据结构呢？有，就是平衡二叉树。

参考资料

【书籍】算法第四版

写在最后

如果您发现文章有任何错误或者对文章有任何疑问，欢迎私信博主或者在评论区指出 💬💬💬。

如果大家有更清晰以及独到的理解，欢迎评论区交流。

最后，感谢您的阅读，如果有所收获的话可以给我点一个 👍 哦。

wang_nn
关注
  • 8
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构——查找(二叉排序树)
weixin_47924016的博客
09-15 1252
二叉排序树查找定义二叉排序树构造二叉排序树查找递归和非递归算法二叉排序树插入递归和非递归算法二叉排序树删除递归和非递归算法二叉排序树查找定义二叉排序树构造二叉排序树查找递归和非递归算法二叉排序树插入递归和非递归算法二叉排序树删除递归和非递归算法。
二叉查找树 减治法——C++代码
05-24
二叉查找树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉查找树中，对于任意节点，其左子树中的...
数据结构：二叉查找树
梁辰兴的博客
09-17 986
二叉查找树（Binary Search Tree，简称BST）是一种特殊的二叉树，其中每个节点都有一个可比较的键和一个关联的值，且对于每个节点，其左子树的所有键都小于节点的键，而右子树的所有键都大于节点的键。简介二叉查找树是一种自我平衡的二叉树，它的中序遍历会得到一个升序的序列。二叉查找树的每个节点都包含一个键和一个值，其中键用于保持树的排序，而值则可以是任何类型的数据。二叉查找树的主要操作包括插入、查找和删除。图示50/ \30 70/ \ / \
C/C++数据结构（十）—— 二叉查找树
Edison's 小宇宙
01-13 2万+
二叉查找树（Binary Search Tree），也称二叉排序树或二叉搜索树。
二叉排序树（二叉查找树、二叉搜索树）（图解+完整代码）
热门推荐
weixin_54186646的博客
04-25 8万+
图解二叉排序树（二叉查找树、二叉搜索树）的插入操作、查找操作、删除操作以及完整的代码实现
数据结构：构建完全二叉查找树
m0_63997099的博客
04-05 1097
减少焦虑，做回自己
JavaScript数据结构之二叉查找树的定义与表示方法
10-20
主要介绍了JavaScript数据结构之二叉查找树的定义与表示方法,简单讲述了二叉查找树的概念、特点及javascript针对二叉查找树的创建、插入、遍历等操作相关实现技巧,需要的朋友可以参考下
二叉查找树python二叉查找树源码
11-22
二叉查找树（Binary Search Tree，BST），也称为二叉排序树，是一种特殊的二叉树数据结构。它的每个节点都包含一个键（key）、一个关联的值、一个指向左子节点的指针和一个指向右子节点的指针。在二叉查找树中，对于...
AVL树数据结构平衡二叉查找树
07-16
在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者...
数据结构——二叉查找树（BST）静态查找表.zip
09-18
二叉查找树（Binary Search Tree，BST），也称为二叉排序树，是计算机科学中用于组织数据的一种数据结构。它是一种特殊的二叉树，每个节点包含一个键（key）、一个关联的值、一个指向左子树的引用以及一个指向右子树...
数据结构【顺序表】
qq_67578580的博客
07-12 1219
我们需要创建一个seqlist.h头文件，seqlist.c文件存放函数，还有一个.c的测试文件。
数据结构之顺序表
m0_73634434的博客
07-10 450
线性表(List)由零个或多个数据组成的有限数列，线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表，链表，栈，队列，字符串。
数据结构和算法（0-1）----递归
yanminghe66666的博客
07-09 623
递归算法，爬楼梯等解法
【排序 - 堆排序】
2302_80393814的博客
07-10 517
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
设备管理中的数据结构
yuanwu932730169的博客
07-11 447
它包含了通道标识符、通道状态（如忙/闲）、与通道连接的控制器表的指针、通道队列的队首指针和队尾指针等信息。功能：DCT主要用于记录单个设备的详细信息，包括设备类型、设备标识符、设备状态（如忙/闲、等待/不等待）、指向控制器表的指针、重复执行次数或时间、设备队列的队首指针等。功能：SDT是系统级别的数据结构，用于记录系统中所有物理设备的情况。功能：COCT主要用于记录单个控制器的详细信息，包括控制器标识符、控制器状态（如忙/闲）、与控制器连接的通道表指针、控制器队列的队首指针和队尾指针等。
数据结构(4.4)——求next数组
最新发布
m0_65240792的博客
07-14 259
next[1]都无脑写0next[2]都无脑写1其他next:在不匹配的位置前边，划一条分界线，模式串一步一步往后退，直到分界线之前"能对上"，或模式串能完全跨过分界线为止，此时j指向哪儿，next数组值就是多少ababaa的next数组//求next[1]??????->??????/i=1->i=2ababaa-> ababaa //j=0,第一个字符匹配失败，只能匹配下一个子串，++i，++jnext[1]=0;//求next[2]a?????->a??????//i=2。
数据结构--单链表实现
LH__1314的博客
07-05 1695
链表和顺序表都是线性表的一种，但是顺序表在物理结构和逻辑结构上都是连续的，但链表在逻辑结构上是连续的，而在物理结构上不一定连续；来看以下图片来认识链表与顺序表的差别这里以动态顺序表为例，和链表中的单链表对比一下动态顺序表单链表这里就可以很清晰的看到顺序表的底层其实就是一个数组，数据的是连续存储的（顺序表物理结构连续）；而链表它每一个数据都不是连续的（链表物理结构上不一定连续）。链表节点通过观察上图，我们会发现链表每一个节点都存放在数据和下一个节点的地址。
【Go系列】 Go语言数据结构
u013379032的博客
07-11 738
定义常量与变量类似，不过使用的关键字是const。const name = "天气真好"在 Go 语言中，常量可以是布尔型、字符串或数字类型。
数据结构二叉查找树AVL
12-06
AVL树是一种自平衡二叉查找树，它的每个节点都保存了一个平衡因子（balance factor），用于判断是否需要进行旋转操作来保持树的平衡。AVL树的平衡因子可以是-1、0或1，当插入或删除节点后，如果某个节点的平衡因子的绝对值大于1，则需要进行旋转操作来保持树的平衡。AVL树的查找、插入和删除操作的时间复杂度都是O(log n)。 以下是一个简单的Python实现AVL树的例子： ```python class AVLNode: def __init__(self, key): self.key = key self.left = None self.right = None self.height = 1 class AVLTree: def __init__(self): self.root = None def insert(self, key): self.root = self._insert(self.root, key) def _insert(self, node, key): if not node: return AVLNode(key) elif key < node.key: node.left = self._insert(node.left, key) else: node.right = self._insert(node.right, key) node.height = 1 + max(self._height(node.left), self._height(node.right)) balance = self._balance(node) if balance > 1 and key < node.left.key: return self._right_rotate(node) if balance < -1 and key > node.right.key: return self._left_rotate(node) if balance > 1 and key > node.left.key: node.left = self._left_rotate(node.left) return self._right_rotate(node) if balance < -1 and key < node.right.key: node.right = self._right_rotate(node.right) return self._left_rotate(node) return node def delete(self, key): self.root = self._delete(self.root, key) def _delete(self, node, key): if not node: return node elif key < node.key: node.left = self._delete(node.left, key) elif key > node.key: node.right = self._delete(node.right, key) else: if not node.left and not node.right: node = None elif not node.left: node = node.right elif not node.right: node = node.left else: temp = self._get_min(node.right) node.key = temp.key node.right = self._delete(node.right, temp.key) if not node: return node node.height = 1 + max(self._height(node.left), self._height(node.right)) balance = self._balance(node) if balance > 1 and self._balance(node.left) >= 0: return self._right_rotate(node) if balance < -1 and self._balance(node.right) <= 0: return self._left_rotate(node) if balance > 1 and self._balance(node.left) < 0: node.left = self._left_rotate(node.left) return self._right_rotate(node) if balance < -1 and self._balance(node.right) > 0: node.right = self._right_rotate(node.right) return self._left_rotate(node) return node def _height(self, node): if not node: return 0 return node.height def _balance(self, node): if not node: return 0 return self._height(node.left) - self._height(node.right) def _left_rotate(self, node): new_root = node.right node.right = new_root.left new_root.left = node node.height = 1 + max(self._height(node.left), self._height(node.right)) new_root.height = 1 + max(self._height(new_root.left), self._height(new_root.right)) return new_root def _right_rotate(self, node): new_root = node.left node.left = new_root.right new_root.right = node node.height = 1 + max(self._height(node.left), self._height(node.right)) new_root.height = 1 + max(self._height(new_root.left), self._height(new_root.right)) return new_root def _get_min(self, node): if not node.left: return node return self._get_min(node.left) def inorder_traversal(self): self._inorder_traversal(self.root) def _inorder_traversal(self, node): if node: self._inorder_traversal(node.left) print(node.key) self._inorder_traversal(node.right) tree = AVLTree() tree.insert(10) tree.insert(20) tree.insert(30) tree.insert(40) tree.insert(50) tree.insert(25) tree.delete(30) tree.inorder_traversal() ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

wang_nn

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

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

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

打赏作者

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

抵扣说明：

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

余额充值