五、高级数据结构和算法：2-3查找树、红黑树

已于 2022-06-18 16:40:07 修改
阅读量263 收藏 1
点赞数
分类专栏： 高级数据结构和算法 文章标签： 数据结构 算法 b树
于 2022-06-18 16:36:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42488216/article/details/125343783
版权

5 2-3查找树、红黑树

5.1 2-3查找树

和二叉树不一样，2-3树每个节点保存1个或者2个的key。
对于普通的2节点(2-node)，要有1个key和左右两个子节点。
对应3节点(3-node)，要有两个Key和三个子节点。

2-3查找树的定义如下：
（1）要么为空，要么：
（2）对于2节点，该节点保存一个key及对应value，以及两个指向左右节点的节点，左节点也是一个2-3节点，所有的值都比key有效，有节点也是一个2-3节点，所有的值比key要大。
（3）对于3节点，该节点保存两个key及对应value，以及三个指向左中右的节点。左节点也是一个2-3节点，所有的值均比两个key中的最小的key还要小；中间节点也是一个2-3节点，中间节点的key值在两个跟节点key值之间；右节点也是一个2-3节点，节点的所有key值比两个key中的最大的key还要大。

在这里插入图片描述

5.1.2 操作

5.1.3 查找

2-3树的查找和二叉查找树类似，要确定一个树是否属于2-3树，我们首先和其跟节点进行比较，如果相等，则查找成功；否则根据比较的条件，在其左中右子树中递归查找，如果找到的节点为空，则未找到，否则返回。
在这里插入图片描述

5.1.4 插入

  • （1）往一个2-node节点插入
    往2-3树中插入元素和BST插入元素一样，首先要进行查找，然后将节点挂到未找到的节点上。
    如果查找后未找到的节点是一个2-node节点，只需要将新的元素放到这个2-node节点里面使其变成一个3-node节点即可。
    在这里插入图片描述
  • （2）往一个3-node节点插入
    往一个3-node节点插入一个新的节点可能会遇到很多种不同的情况。例如：
    a）只包含一个3-node节点
    在这里插入图片描述
    b）节点是3-node，父节点是2-node
    和第一种情况一样，我们也可以将新的元素插入到3-node节点中，使其成为一个临时的4-node节点，然后，将该节点中的中间元素提升到父节点即2-node节点中，使其父节点成为一个3-node节点，然后将左右节点分别挂在这个3-node节点的恰当位置。
    在这里插入图片描述
    c）节点是3-node，父节点也是3-node
    当插入的节点是3-node的时候，将该节点拆分，中间元素提升至父节点，但是此时父节点是一个3-node节点，插入之后，父节点变成了4-node节点，然后继续将中间元素提升至其父节点，直至遇到一个父节点是2-node节点，然后将其变为3-node，不需要继续进行拆分。
    在这里插入图片描述
    d）根节点分裂
    当根节点到字节点都是3-node节点的时候，这是如果要在字节点插入新的元素的时候，会一直查分到跟节点，在最后一步的时候，跟节点变成了一个4-node节点，这个时候，就需要将跟节点查分为两个2-node节点，树的高度加1。

5.1.5 本地转换

将一个4-node拆分为2-3node涉及到6种可能的操作。这4-node可能在跟节点，也可能是2-node的左子节点或者右子节点。或者是一个3-node的左，中，右子节点。所有的这些改变都是本地的，不需要检查或者修改其他部分的节点。所以只需要常数次操作即可完成2-3树的平衡。
在这里插入图片描述
注：2-3树之所以能够保证在最差的情况下的效率的原因在于其插入之后仍然能够保持平衡状态。

5.1.6 性质

这些本地操作保持了2-3树的平衡。对于4-node节点变形为2-3节点，变形前后树的高度没有发生变化。只有当跟节点是4-node节点，变形后树的高度才加一。
在这里插入图片描述

5.1.7 AVL树 vs. 2-3查找树

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

5.2 红黑树(Red-Black Tree)

红黑树是一种具有红色和黑色链接的BST。

《算法导论》中对红黑树的定义（针对的是节点颜色，基于2-3-4数）：
（1）节点是红色或黑色树
（2）根节点和叶子节点（NIL节点）都是黑色。
（3）每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点，也就是没有5-node)
（4）从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。(黑色节点完美平衡)

《算法》中对红黑树的定义（针对的是线的颜色，基于2-3树）：
（1）红色的线永远是左侧链接。（强行的规定）
（2）没有一个节点同时链了两条红色的线。（也就是没有4-node）
（3）任何从根到叶子节点的路径上有相同颜色的黑线。(黑线节点完美平衡)

  • 红黑树
    在这里插入图片描述

5.2.1 背景

2-3查找树能保证在插入元素之后能保持树的平衡状态，最坏情况下即所有的子节点都是2-node，树的高度为lgN，从而保证了最坏情况下的时间复杂度。但是2-3树实现起来比较复杂。红黑树是一种简单实现2-3树的数据结构。

  • 红黑树平衡
    在这里插入图片描述

  • 红黑树转2-3树
    在这里插入图片描述
    本质：红黑树是对2-3查找树进行编码。

对2-3查找树中的3-nodes节点添加额外的信息。
红黑树中将节点之间的链接分为两种不同类型。
红色链接：链接两个2-nodes节点来表示一个3-nodes节点。
黑色链接：链接普通的2-3节点。

在这里插入图片描述
从边的颜色到节点的颜色
BST的每一个节点上增加一个新的表示颜色的标记。该标记指示该节点指向其父节点的颜色。

5.2.2 操作

  • 平衡化
    与AVL相同，红黑树也需要通过旋转保持平衡；不同的是旋转后，需要改变节点的颜色。

5.2.3 旋转(Rotate)

  • 左旋
    将一个向右倾斜的红色链接旋转为向左链接,将红线链接的两个节点中的一个较大的节点移动到根节点上。

在这里插入图片描述- 右旋
将一个向左倾斜的红色链接旋转为向右链接,将红线链接的两个节点中的一个较大的节点移动到根节点上。

在这里插入图片描述

  • 暂时的旋转
    在这里插入图片描述
    旋转颜色变化规律：上升节点(旋转节点)变为原来父节点的颜色，下降节点变为红色。

  • AVL和红黑树旋转的比较
    在这里插入图片描述
    红黑树在AVL的基础上加入了颜色的变化

5.2.4 颜色反转(Color Flip)

当出现一个临时的4-node的时候，即一个节点的两个子节点均为红色。子节点颜色为黑色，父节点的颜色设置为红色；反之亦然。
在这里插入图片描述
在这里插入图片描述
因为2是根节点，所以要根黑
二叉树中，根节点永远是黑色。

5.2.5 红节点转移(Move Red)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
本质：红节点转移实质上形成一个5节点。

  • 实例
#include <iostream>
using namespace std;

enum COLOR {RED,BLACK};

template <typename T>
class _Node {
public:
    T val;
    COLOR color = BLACK;
    _Node* left;
    _Node* right;
    _Node(const T& val):val(val),left(nullptr),right(nullptr) {}
    _Node(const T& val,_Node* left,_Node* right):val(val),left(left),right(right) {}
};

typedef _Node<int> Node;
//     P          Q
//    / \        / \
//   q   C      A   p
//  / \            / \
// A   B          B   C
Node* RotateRight(Node* root) {
    Node* p = root;
    Node* q = p->left;
    Node* b = q->right;
    q->right = p;
    p->left = b;

    q->color = p->color;
    p->color = RED;
    return q;
}
//   P            Q
//  / \          / \
// A   q        p   C
//    / \      / \
//   B   C    A   B
Node* RotateLeft(Node* root) {
    Node* p = root;
    Node* q = p->right;
    Node* b = q->left;
    q->left = p;
    p->right = b;
    q->color = p->color;
    p->color = RED;
    return q;
}
bool IsRed(Node* root) {
    return nullptr!=root && root->color==RED;
}
Node* FiipColor(Node* root) {
    if(IsRed(root->left) && IsRed(root->right)) {
        root->left->color = BLACK;
        root->right->color = BLACK;
        root->color = RED;
    }
    
    if(!IsRed(root->left) && !IsRed(root->right)) {
        root->left->color = RED;
        root->right->color = RED;
        root->color = BLACK;
    }
    return root;
}

//   P         P         P            B
//  / \       / \       / \          / \
// A   Q     a   q     a   b        p   q
//    /         /           \      /
//   b         b             q    a
Node* MoveRedLeft(Node* root){
    root = FiipColor(root);
    if(IsRed(root->right->left)){
	root->right = RotateRight(root->right);
	root = RotateLeft(root);
    }
    return root;
}
//     P        P         Q
//    / \      / \       / \
//   Q   B    q   b     a   p
//  /        /               \
// a        a                 b
Node* MoveRedRight(Node* root){
    root = FiipColor(root);
    if(IsRed(root->left->left)){
        root = RotateRight(root);
    }
    return root;
}
void Preorder(Node* root) {
    if(nullptr == root) return;

    if(root->left) {
        cout << root->val << "--" << root->left->val;
        if(root->left->color==RED) cout << "[color=red]";
        cout << endl;
    }
    if(root->right) {
        cout << root->val << "--" << root->right->val;
        if(root->right->color==RED) cout << "[color=red]";
        cout << endl;
    }

    Preorder(root->left);
    Preorder(root->right);
}

Node* Balance(Node* root) {
    if(IsRed(root->right) && !IsRed(root->left)) root = RotateLeft(root);
    if(IsRed(root->left) && IsRed(root->left->left)) root = RotateRight(root);
    if(IsRed(root->left) && IsRed(root->right)) root = FiipColor(root);
    return root;
}

int main() {
    Node a(1);
    Node b(2);
    Node c(3);
    c.color = RED;
    a.right = &b;
    b.right = &c;

    Preorder(&a);
    a.right = RotateLeft(&b);
    Preorder(&a);
    a.right = RotateRight(&c);
    Preorder(&a);
}

1--2
2--3[color=red]
1--3
3--2[color=red]
1--2
2--3[color=red]

5.2.6 插入

一切为了平衡，树根到叶子节点的路径上黑边的个数(黑节点个数)决定平衡。
从上到下查找位置，插入节点为红叶子节点，然后从下到上回溯平衡。

  • 往一个2-node节点底部插入新的节点
    （1）按照BST遍历，新插入的节点标记为红色。
    为什么新插入节点是红色？为了保证插入后树是平衡的(每条分支黑边个数不发生改变)。
    （2） 如果新插入的节点在父节点的右子节点，则需要进行左旋操作。
    为什么要左旋？因为红色的线永远是左侧链接。
    在这里插入图片描述
  • 往一个3-node节点底部插入新的节点
    （1）插入的节点比现有的两个节点都大，新插入的节点连接到右边子树上，颜色反转。
    （2）插入的节点比现有的两个节点都小，新插入的节点连接到最左侧，中间节点右旋，颜色反转。
    （3）插入的节点的值位于两个节点之间，新节点插入到左侧节点的右子节点。先以中间节点左旋至情况2，再中间节点右旋，颜色反转。

在这里插入图片描述

3-node节点底部插入新的节点，可能会导致父节点不满足红黑树的特点(完美平衡)，可以从下往上回溯更新节点的颜色(与AVL判断平衡因子更新树高相似)，直到平衡。

  • 3-node节点底部插入新的节点的连锁反应实例1
    在这里插入图片描述
  • 3-node节点底部插入新的节点的连锁反应实例2
    在这里插入图片描述
  • 步骤：
    （1）执行标准的二叉查找树插入操作，新插入的节点元素用红色标识。
    （2）如果需要对4-node节点进行旋转操作
    （3）如果需要，调用FlipColor方法将红色节点提升
    （4）如果需要，左旋操作使红色节点左倾。
    （5）在有些情况下，需要递归调用Case1 Case2，来进行递归操作。
  • 平衡操作
    （1）如果节点的右子节点为红色，且左子节点位黑色，则进行左旋操作
    （2）如果节点的左子节点为红色，并且左子节点的左子节点也为红色，则进行右旋操作
    （3）如果节点的左右子节点均为红色，则执行FlipColor操作，提升中间结点。

红黑树能够保证符号表的所有操作即使在最坏的情况下都能保证对数的时间复杂度，也就是树的高度。

  • 最坏情况
    红黑树中除了最左侧路径全部是由3-node节点组成，即红黑相间的路径长度是全黑路径长度的2倍。红黑树的高度不超过2lgN
    在这里插入图片描述
  • 2-3 nodes树与RB树关系
    2-3 nodes树中的4-node分裂成3个2-node，并让中间节点上移；等价于红黑树中的左右旋转；
    2-3 nodes树中间节点上移与父节点融合过程；等价于红黑树中的反色操作。

5.2.7 查找

与BST一致。

5.2.8 删除

删除需要保证删除节点是非2-node的叶子节点，即必须是3-node和4-node。所以查找过程需要把过程中的2-node转化成3-node和4-node，删除后，在把3-node和4-node还原。

  • 实例
#include <iostream>
#include <stack>
#include <vector>
#include <queue>
using namespace std;

enum COLOR {RED,BLACK};

template <typename T>
class _Node {
public:
    T val;
    _Node* left;
    _Node* right;
    COLOR color = RED;
    _Node(const T& val):val(val),left(nullptr),right(nullptr) {}
    _Node(const T& val,_Node* left,_Node* right):val(val),left(left),right(right) {}
};

template <typename T>
class RBTree {
    typedef _Node<T> Node;
    Node* m_root = nullptr;
public:
    bool Search(const T& val) {
        return Search(m_root,val);
    }
    void Insert(const T& val) {
        if(Search(val)) return;
        m_root = Insert(m_root,val);
	m_root->color = BLACK;
    }
    void Remove(const T& val) {
	m_root->color = RED;
        m_root = Remove(m_root,val);
	m_root->color = BLACK;
    }
    void Print() {
        Preorder(m_root);
    }
private:
    bool Search(Node* root,const T& val) {
        if(nullptr == root) return false;
        if(root->val == val) return true;
        if(root->val < val) {
            return Search(root->right,val);
        } else {
            return Search(root->left,val);
        }
        // return Search(root->val<val?root->right:root->left,val);
    }
    Node* Remove(Node* root,const T& val) {
        if(nullptr == root) return nullptr;
        if(root->val > val) {
	    	if(!IsRed(root->left) && !IsRed(root->left->left)) root = MoveRedLeft(root);
	    	root->left = Remove(root->left,val);
		}else {
	    	if(IsRed(root->left)) root = RotateRight(root);
	    	if(val == root->val && nullptr == root->right) {delete root; return nullptr;}
	    	if(!IsRed(root->right) && !IsRed(root->right->left)) root = MoveRedRight(root);
	    	if(val == root->val){
		    	T minval = Minimun(root->right);
		    	root->val = minval;
		    	root->right = Remove(root->right,minval);
		    	// root->right = DeleteMin(root->right);
	    	}else{
                root->right = Remove(root->right,val);
	    	}
        }
        return Balance(root);
    }
    Node* DeleteMin(Node* root) {
        if(nullptr == root) throw runtime_error("root is null");
        Node* prev = nullptr;
        Node* cur = root;
        while(nullptr != cur->left) {
            prev = cur;
            cur = cur->left;
        }
        delete cur;
        return root;
    }
    T Minimun(Node* root) {
        if(nullptr == root) throw runtime_error("root is null");
        while(nullptr != root->left) root = root->left;
        return root->val;
    }
    T Maximun(Node* root) {
        if(nullptr == root) throw runtime_error("root is null");
        while(nullptr != root->right) root = root->right;
        return root->val;
    }
    Node* Insert(Node* root,const T& val) {
        if(nullptr == root) return new Node(val);
        if(root->val>val) {
            root->left = Insert(root->left,val);
        } else {
            root->right = Insert(root->right,val);
        }
        return Balance(root);
    }
//     P          Q
//    / \        / \
//   q   C      A   p
//  / \            / \
// A   B          B   C 
Node* RotateRight(Node* root){
   Node* p = root;
   Node* q = p->left;
   Node* b = q->right;
   q->right = p;
   p->left = b;

   q->color = p->color;
   p->color = RED;
   return q;
}
//   P            Q
//  / \          / \
// A   q        p   C
//    / \      / \
//   B   C    A   B
Node* RotateLeft(Node* root){
   Node* p = root;
   Node* q = p->right;
   Node* b = q->left;
   q->left = p;
   p->right = b;
   q->color = p->color;
   p->color = RED;
   return q;
}
bool IsRed(Node* root){
   return nullptr!=root && root->color==RED;
}
Node* FiipColor(Node* root) {
    if(IsRed(root->left) && IsRed(root->right)) {
        root->left->color = BLACK;
        root->right->color = BLACK;
        root->color = RED;
    }else if(!IsRed(root->left) && !IsRed(root->right)) {
        root->left->color = RED;
        root->right->color = RED;
        root->color = BLACK;
    }
    return root;
}
// 大写代表黑色，小写代表红色
//   P         P         P            B
//  / \       / \       / \          / \
// A   Q     a   q     a   b        p   q
//    /         /           \      /
//   b         b             q    a
Node* MoveRedLeft(Node* root){
    root = FiipColor(root);
    if(IsRed(root->right->left)){
		root->right = RotateRight(root->right);
		root = RotateLeft(root);
    }
    return root;
}
//     P        P         Q
//    / \      / \       / \
//   Q   B    q   b     a   p
//  /        /               \
// a        a                 b
Node* MoveRedRight(Node* root){
    root = FiipColor(root);
    if(IsRed(root->left->left)){
        root = RotateRight(root);
    }
    return root;
}

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

    if(root->left) {
	cout << root->val << "--" << root->left->val;
    	if(root->left->color==RED) cout << "[color=red]"; 
    	cout << endl;
    }
    if(root->right) {
        cout << root->val << "--" << root->right->val;
    	if(root->right->color==RED) cout << "[color=red]"; 
    	cout << endl;
    }

    Preorder(root->left);
    Preorder(root->right);
}

Node* Balance(Node* root){
    if(IsRed(root->right) && !IsRed(root->left)) root = RotateLeft(root);
    if(IsRed(root->left) && IsRed(root->left->left)) root = RotateRight(root);
    if(IsRed(root->left) && IsRed(root->right)) root = FiipColor(root);
    return root;
}

};
int main() {

    RBTree<int> intbst;

    int arr[] = {1,3,5,7,2,4,8};
    for(auto n:arr){
        intbst.Insert(n);
    }
    intbst.Print();

    int n;
    while(cin >> n) {
        intbst.Remove(n);
    	intbst.Print();
    }
}

结果：

5--3[color=red]
5--8
3--2
3--4
2--1[color=red]
8--7[color=red]

树：
blog.csdnimg.cn/93c32f2f7e9d448e9340355504cac8ab.png)
删除结点4

5--2[color=red]
5--8
2--1
2--3
8--7[color=red]

删除后的树：
在这里插入图片描述
再删除结点2：

5--3
5--8
3--1[color=red]
8--7[color=red]

在这里插入图片描述

5.2.9 插入 vs. 删除

  • 插入操作
操作目的改变项保持项执行条件
左旋/右旋调节平衡,使之符合红黑树规定节点的位置和颜色始终保持BST特点红节点不满足红黑树规定
颜色反转调节平衡,使之符合红黑树规定(等价于2-3树4节点差分)改变节点的颜色始终保持BST特点红节点不满足红黑树规定
  • 删除操作
操作目的改变项保持项执行条件
左旋/右旋旋转红节点到要删除的分支，便于后续删除节点的位置和颜色始终保持BST特点删除右子树节点，左子树的根节点为红节点时。
颜色反转增加可使用的红节点(等价于2-3树节点4节点组合)改变节点的颜色始终保持BST特点左右子节点为黑节点时
红节点移动移动红节点到要删除的分支，便于后续删除节点的位置和颜色始终保持BST特点向下查找删除节点，当前子树连续两个黑节点时。
_深蓝.
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
从2-3树理解红黑树
02-25
《从2-3树理解红黑树》 2-3树和红黑树是两种重要的自平衡二叉查找树（AVL树）类型，它们在数据结构和算法领域扮演着重要角色，...对于学习和掌握高级数据结构与算法的开发者来说，深入理解2-3树和红黑树是至关重要的。
S3_DS_LAB：数据结构和算法，CS-201 KTU
02-04
5. **树**：分层数据结构，如二叉树、二叉搜索树、平衡树（AVL、红黑树等），用于高效搜索和排序。 6. **哈希表**：通过哈希函数实现快速查找和插入，常用于实现字典和缓存。 7. **堆**：一种部分有序的树形数据结构...
数据结构——平衡树【2-3查找树、红黑树】
龍弟-idea的博客
01-17 431
查找树的定义: 一棵标准的二叉查找树中的结点称为2-结点(含有一个键和两条链)，而现在我们引入3-结点（含有两个键和三条链）。 2- 结点： 含有一个键( 及其对应的值 ) 和两条链，左链接指向 2-3 树中的键都小于该结点，右链接指向的 2-3 树中的键都大于该结点。3-结点： 含有两个键 ( 及其对应的值 ) 和三条链，左链接指向的 2-3 树中的键都小于该结点，中链接指向的 2-3 树中的键都位于该结点的两个键之间，右链接指向的2-3 树中的键都大于该结点。 查找 将二叉查找树的查找算...
2-3查找树 红黑树
sabot_v的博客
11-12 187
目录一. 2-3查找树1. 概述2. 插入方法 一. 2-3查找树 1. 概述 为了保证查找树的平衡性，我们需要一些灵活性，因此在这里我们允许树中的一个结点保存多个键。确切的说，我们将一棵标准的二叉查找树中的结点称为2-结点(含有一个键和两条链)，而现在我们引入3-结点，它含有两个键和三条链。2-结点和3-结点中的每条链都对应着其中保存的键所分割产生的一个区间。 2-3树其每个非叶节点都有两个或三个子女，而且所有叶都在统一层上。2-3树不是二叉树，其节点可拥有3个孩子。不过，2-3树与满二叉树相似。高为h的
查找树（三）：红黑树（red black tree）
Ju的博客
09-02 603
目录：1. 红黑树（red black tree）2. 插入操作2.1 情况32.2 情况42.2.1 单旋转2.2.2 双旋转3. 删除操作3.1 情况1（X是黑色，X的兄弟是红色）3.2 情况2（X是黑色，X的兄弟是黑色）3.2.1 X的父节点为红色3.2.2 X的父节点为黑色 1. 红黑树（red black tree） 关于自平衡的二叉查找树，AVL树是比较经典的一种，前面也对其实现原理做了比较详细的介绍。当然，相关的数据结构肯定不止这一种，历史上AVL树流行的另一种变种是红黑树。 红黑树通过给节
【数据结构—查找】红黑树
青山的青衫的博客
04-03 1322
文章目录红黑树一、定义与性质定义性质二、插入（双红修正->按照x的叔叔u分类）1.x的叔叔是黑色（如果是外结点，也是黑色！）1.1 g到x的路径为LL型（爷爷到自己）1.2 g到x的路径为RR型1.3 g到x的路径为LR型1.4 g到x的路径为RL型2.x的叔叔是红色先染色2.1.若g为根结点，结束。2.2.若g被染红，并且g父红，继续向上双红修正总结三、删除（双黑修正->按照x的兄弟s分类）1.兄弟s为黑，且有红孩子1.1 p到n的路径为LL型1.2 p到n的路径为LR型1.3 p到n的路径为
九种查找算法-红黑树
最新发布
螺旋翻转大大雄
01-31 402
红黑树的思想就是对2-3查找树进行编码，尤其是对2-3查找树中的3-nodes节点添加额外的信息。黑色链接用来链接普通的2-3节点。特别的，使用红色链接的两个2-nodes来表示一个3-nodes节点，并且向左倾斜，即一个2-node是另一个2-node的左子节点。2-3查找树能保证在插入元素之后能保持树的平衡状态，最坏情况下即所有的子节点都是2-node，树的高度为lgn，从而保证了最坏情况下的时间复杂度。再将3节点的位于中间的子节点的父节点设置为父节点中那个红色的节点，如图4的所示；
算法与数据结构：13-树5.pdf
09-20
3. **平衡树**：为了保持高效查找性能，平衡树如AVL树和红黑树被提出。AVL树要求任意节点的两个子树高度差不超过1，确保了查找效率始终为O(log n)。红黑树则通过颜色属性保持大致平衡，牺牲了一定的平衡性以简化插入...
数据结构与算法：Python语言实现【源代码】Source Code Files - Packaged.zip
06-30
数据结构与算法是计算机科学的基础，对于理解和解决复杂问题至关重要。本书"数据结构与算法：Python语言实现"提供了丰富的源代码，旨在帮助读者通过实践掌握这些核心概念。Python作为一种易于学习且功能强大的编程...
数据结构和算法详细分析用C-python-java详解.rar
08-19
Python简洁易读，适合初学者，提供了丰富的库支持数据结构和算法实现，如内置的`heapq`模块实现堆操作，`collections`模块提供高级数据结构。 5. **Java语言实现**： Java面向对象，提供了标准库`java.util`中的...
数据结构课设----文章搜索关键字（包含算法：KMP\数字搜索树\SUNDAY）
04-30
作家写文章常常偏爱某些词语（特征词），因此常用“统计某些词语在某文章中出现频率”的办法作为判断“该文章是否出自该作者”的依据。现在已知某作家偏爱三个特征词，针对一篇不知作者的英语文章，需要通过“分析特征词在文中出现频率”判断该文章是该作家所作的可能性。
数据结构和算法（十三）查找树
jwang的博客
08-19 505
前言 本章讨论一下树的查找，也就是查找树 方法 1.概念 对于查找树而言，我们最值得研究的就是二叉查找树。 二叉查找/搜索/排序树（BST）的定义： 或者是一棵空树，或者是具有下列性质的树： 若它的左子树不为空，则左子树所有结点的值都小于根节点的值 若它的右子树不为空，则右子树所有结点的值都大于根节点的值 它的左右子树也必须为二叉查找树 二叉查找树的示例： 上图...
数据结构树结构定义
一念永恒
01-03 1378
树中名词解释的定义： 结点：指树中的一个元素； 结点的度：指结点拥有的子树的个数，二叉树的度不大于2； 数的度：指树中的最大结点度数； 叶子：度为0的结点，也称为终端结点； 高度：叶子节点的高度为1，根节点高度最高； 层：根在第一层，以此类推；   二叉树 定义： 由一个结点和两颗互不相交、分别称为这个根的左子树和右子树的二叉树构成。 性质： 二叉树的第i层上至多有2^(i...
数据结构基础--搜索树
RXY24601的博客
11-13 1430
包括：二叉搜索树，平衡二叉树，m叉搜索树，B-树
数据结构与算法之2-3树
蘑菇蘑菇不会开花的专栏
07-25 380
我们在上篇二叉查找树中曾介绍过二叉查找树有可能会出现其中一个极端情况，所有的结点变成了一条链。如图 我们当然希望我们能保存二叉查找树的平衡性，但是在动态插入过程中保证树的完美平衡代价太大了。我们退而求其次，学习一种新的数据结构。 定义 2-3查找树是一种平衡树的思想，我们可以将标准二叉查找树的结点称为2-结点（含有一个键和两条链），而现在我们引入3-结点，它含有两个键和三条链，每一条链就是一个分区。一棵2-3查找树要么为空，要么满足满足下面两个要求： A、2-结点：含有一个键（及对应值）和两条链接，左链接
2-3查找树与红黑树
sunlilan的博客
11-18 271
二叉查找树一种能够将链表插入的灵活性与有序数组查找的高效性结合起来的符号表实现。public class BST<Key extends Comparable<Key>,Value>{ private class Node{ Key key; Value val; Node left,right; int N; //以该结点为根
平衡查找树——2-3查找树——红黑树(1)
这个世界，它还是它。
09-30 3404
二叉查找树VS平衡查找树Binary Search Tree possibilitiesBalanced Search Trees如何学 平衡查找树为了保证之前学习的二分查找树BST的平衡性，解决在最坏情况时高度为N的情况，这里有几种平衡查找树： AVL 2-3 Search Trees Red-black BSTs ——红黑二叉查找树 直接关注最重要的一种搜索树——红黑树，在SGI STL中红黑树
二叉查找树BST和红黑树，果然。。。
兴华的博客
11-04 1614
红黑树是一种可以自平衡的二叉查找树；
数据结构-81
08-03
南京气象学院计算机科学系的这个章节详细探讨了查找算法的基础理论，重点介绍了如何在不同数据结构（如线性表、哈希表和树表）中执行高效的查找操作，并强调了数据结构选择对查找效率的影响。理解这些概念对于学习和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值