平衡树基础

最新推荐文章于 2024-08-15 05:02:54 发布
最新推荐文章于 2024-08-15 05:02:54 发布
阅读量864 收藏 24
点赞数 22
分类专栏： 算法与数据结构 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liu_xinLL/article/details/135712342
版权

一，二叉排序树

1.结构定义

2.结构操作

（1）节点 插入
  • 从根节点开始，逐层比较
  • 要插入的节点比当前节点大，指针往右子树移
  • 要插入的节点比当前节点小，指针往左子树移
  • 直到遍历到空节点，根据上述规则，插入到空节点
（2）节点删除
1、删除叶 ⼦节点 
  • 直接删除
2、删除出度为1的节点 
  • 提升唯一的子树
3、删除出度为2的节点
  • 找到要删除节点的前驱或者后继，与其中之一替换后，转换为度为1的节点问题
前驱：从要删除的节点的左子树开始，向右遍历到的最大节点为要删除的节点的前驱
后继：从要删除的节点的右子树开始，向左遍历到的最小节点为要删除的节点的后继
代码实现：
#include <iostream>
#include <cstdio>
#include <ctime>
#include <cstdlib>
using namespace std;
#define KEY(n) (n ? n->key : -1)
typedef struct Node {
        int key;
        struct Node* lchild, * rchild;
}Node;
Node* getNewNode( int key) {
       Node* p = (Node*)malloc( sizeof (Node));
       p->key = key;
       p->lchild = p->rchild = NULL;
        return p;
}
//插入，返回当前子树根节点
Node* insert( Node * root , int key ) {
        if ( root == NULL ) return getNewNode( key );
        if ( root ->key == key ) return root ;
        if ( key > root ->key) root ->rchild = insert( root ->rchild, key );
        else root ->lchild = insert( root ->lchild, key );
        return root ;
}
Node * predecessor( Node * root ) {
        Node * temp = root ->lchild;
        while (temp->rchild)temp = temp->rchild;
        return temp;
}
//删除，返回当前子树根节点
Node * erase( Node * root , int key ) {
        if ( root == NULL ) return root ;
        if ( key < root ->key) root ->lchild = erase( root ->lchild, key );
        else if ( key > root ->key) root ->rchild = erase( root ->rchild, key );
        else {
               //要删除节点出度为0的节点
               if ( root ->rchild == NULL && root ->lchild == NULL ) {
                      free( root );
                       //返回给父节点指针
                       return NULL ;
              }
               //要删除节点出度为1的节点
               else if ( root ->lchild == NULL || root ->rchild == NULL ) {
                       Node * temp = root ->lchild ? root ->lchild : root ->rchild;
                      free( root );
                       return temp;
              }
               //要删除节点出度为2的节点
               else {
                       Node * temp = predecessor( root );
                       root ->key = temp->key;
                       root ->lchild = erase( root ->lchild, temp->key);
              }
       }
        return root ;
}
void clear( Node * root ) {
        if ( root == NULL ) return ;
       clear( root ->lchild);
       clear( root ->rchild);
       free( root );
        return ;
}
//前序遍历
void output( Node * root ) {
        if ( root == NULL ) return ;
       printf( "(%d ; %d, %d)\n" ,
               KEY ( root ),
               KEY ( root ->lchild),
               KEY ( root ->rchild)
       );
       output( root ->lchild);
       output( root ->rchild);
        return ;
}
//中序遍历
void in_order( Node * root ) {
        if ( root == NULL ) return ;
       in_order( root ->lchild);
       printf( "%d " , root ->key);
       in_order( root ->rchild);
        return ;
}
int main() {
       srand(time(0));
#define MAX_OP 10
        Node * root = NULL ;
        for ( int i = 0; i < MAX_OP ; i++) {
               int key = rand() % 100;
              printf( "insert key %d to BST\n" , key);
              root = insert(root, key);
       }
       output(root);
       printf( "in order : " );
       in_order(root);
       printf( "\n" );
        int x;
        while (~scanf_s( "%d" , &x)) {
              printf( "erase %d from BST\n" , x);
              root = erase(root, x);
              in_order(root); printf( "\n" );
       }
        return 0;
}

二，AVL树

1.k1为从下往上看的第一个失衡的位置（k1左右子树的高度差大于1）
2.LL型k1的左子树要更高，k1的左子树的左子树要更高（和各自的右子树相比）
RL型 -->先小右旋，在大左旋
代码演示：
#include <iostream>
#include <cstdio>
#include <ctime>
#include <cmath>
#include <cstdlib>
using namespace std;
typedef struct Node {
        int key, h;
        struct Node * rchild, * lchild;
} Node ;
//创建虚拟空节点
Node __NIL;
#define NIL (&__NIL)
#define K (n) (n->key)
#define H (n) (n->h)
#define L (n) (n->lchild)
#define R (n) (n->rchild)
//初始化虚拟空节点
__attribute__((constructor));
void init__NIL() {
        K ( NIL ) = -1;
        H ( NIL ) = 0;
        L ( NIL ) = R ( NIL ) = NIL ;
        return ;
}
Node * getNewNode( int key ) {
        Node * p = ( Node *)malloc( sizeof ( Node ));
       p->key = key ;
       p->h = 1;
       p->lchild = p->rchild = NIL ;
        return p;
}
//更新根节点的高度
void update_height( Node * root ) {
        H ( root ) = ( H ( L ( root )) > H ( R ( root )) ? H ( L ( root )) : H ( R ( root ))) + 1;
        return ;
}
//左旋
Node * left_rotate( Node * root ) {
       printf( "left rotate : %d\n" , root ->key);
        Node * new_node = root ->rchild;
        root ->rchild = new_node->lchild;
       new_node->lchild = root ;
       update_height( root );
       update_height(new_node);
        return new_node;
}
//右旋
Node * right_rotate( Node * root ) {
       printf( "right rotate : %d\n" , root ->key);
        Node * new_node = root ->lchild;
        root ->lchild = new_node->rchild;
       new_node->rchild = root ;
       update_height( root );
       update_height(new_node);
        return new_node;
}
//维护类型--失衡类型
const char * type_str[5] = {
        "" ,
        "maintain type : LL"
        "maintain type : LR"
        "maintain type : RR"
        "maintain type : RL"
};
//维护平衡状态
Node * maintain( Node * root ) {
        //不用维护
        if (abs( H ( L ( root )) - H ( R ( root ))) <= 1) return root ;
        //记录失衡类型
        int type = 0;
        if ( H ( L ( root )) > H ( R ( root ))) {
               if ( H ( R ( L ( root ))) > H ( L ( L ( root )))) {
                       // LR --> 小左旋
                       root ->lchild = left_rotate( root ->lchild);
                      type += 1;
              }
               // LL/LR --> 大右旋
               root = right_rotate( root );
              type += 1;
       }
        else {
               if ( H ( L ( R ( root ))) > H ( R ( R ( root )))) {
                       //RL --> 小右旋
                       root ->rchild = right_rotate( root ->rchild);
                      type += 1;
              }
               // RR/RL --> 大左旋
               root = left_rotate( root );
              type += 1;
       }
       printf( "%s\n" , type_str[type]);
        return root ;
}
Node * insert( Node * root , int key ) {
        if ( root == NIL ) return getNewNode( key );
        if ( root ->key == key ) return root ;
        if ( key < root ->key) root ->lchild = insert( root ->lchild, key );
        else root ->rchild = insert( root ->rchild, key );
        //重新计算当前节点高度
       update_height( root );
        //维护平衡
        return maintain( root );
}
Node * predecessor( Node * root ) {
        Node * temp = root ->lchild;
        while (temp->rchild != NIL ) temp = temp->rchild;
        return temp;
}
Node * erase( Node * root , int key ) {
        if ( root == NIL ) return root ;
        if ( key < root ->key) root ->lchild = erase( root ->lchild, key );
        else if ( key > root ->key) root ->rchild = erase( root ->rchild, key );
        else {
               //删除度为0，1的节点
               if ( root ->lchild == NIL || root ->rchild == NIL ) {
                       Node * temp = root ->lchild != NIL ? root ->lchild : root ->rchild;
                      free( root );
                       return temp;
              }
               //删除度为2的节点
               else {
                       Node * temp = predecessor( root );
                       root ->key = temp->key;
                       root ->lchild = erase( root ->lchild, temp->key);
              }
       }
        //重新计算当前节点高度
       update_height( root );
        //维护平衡
        return maintain( root );
}
Node * find( Node * root , int key ) {
        if ( root == NIL ) return NIL ;
        if ( root ->key == key ) return root ;
        if ( key < root ->key) return find( root ->lchild, key );
        return find( root ->rchild, key );
}
void clear( Node * root ) {
        if ( root == NULL ) return ;
       clear( root ->lchild);
       clear( root ->rchild);
       free( root );
        return ;
}
//前序遍历
void output( Node * root ) {
        if ( root == NIL ) return ;
       printf( "(%d[%d] | %d, %d)\n" ,
               K ( root ), H ( root ),
               K ( L ( root )), K ( R ( root ))
       );
       output( root ->lchild);
       output( root ->rchild);
        return ;
}
int main() {
       srand(time(0));
        Node * root = NIL ;
        int x;
        // insert
        while (~scanf_s( "%d" , &x)) {
               if (x == -1) break ;
              printf( "insert %d to avl tree\n" , x);
              root = insert(root, x);
              output(root);
       }
        // erase
        while (~scanf_s( "%d" , &x)) {
               if (x == -1) break ;
              printf( "erase %d from avl tree\n" , x);
              root = erase(root, x);
              output(root);
       }
        // find
        while (~scanf_s( "%d" , &x)) {
               if (x == -1) break ;
              printf( "find %d in avl : %d\n" , x, find(root, x) != NIL );
       }
        return 0;
}

三，红黑树

插入操作

原则：
  • 调整前后，每条路径黑色节点数不变。
  • 对于颜色不确定的节点，其父节点一定是黑色。
  • 插入到红黑树的节点一定为红色。
情况1：
调整方法：
将祖父节点调整成红色，叔父节点和父节点调整成黑色
情况2：
左边红色节点的左子树是红色，导致失衡--LL型
调整方式： 大右旋-->红色上浮/下沉（大右旋后的根节点及其左右子树改成了红黑黑/黑红红）
情况3：
左边红色节点的右子树是红色，导致失衡--LR型
调整方式： 小左旋 --> 大右旋-->红色上浮/下沉（大右旋后的根节点及其左右子树改成了红黑黑/黑红红）
情况4：
右边红色节点的右子树是红色，导致失衡--RR型
调整方式： 大左旋-->红色上浮/下沉（大左旋后的根节点及其左右子树改成了红黑黑/黑红红）
情况5：
右边红色节点的左子树是红色，导致失衡--RL型
调整方式： 小右旋 --> 大左旋-->红色上浮/下沉（大右旋后的根节点及其左右子树改成了红黑黑/黑红红）

红黑树的删除操作

1.删除度为零的红色节点：直接删除
2.删除度为1的红色节点：不存在度为1的红色节点，违背了红黑树的第五条性质（不同路径的黑色节点数相同）；
3.删除度为1的黑色节点：其唯一子树不能存在黑色节点，修改方法：红提升，并变黑；
以上三种删除情况，不会造成红黑树失衡
4.删除度为0的黑色节点：将被删除的黑色节点的NIL节点设置成双重黑节点；
那么双重黑节点违反了红黑树的性质，引发红黑树的失衡，则 删除调整的操作主要是解决删除度为0的黑色节点而产生的双重黑节点
ps:删除度为2的节点可以转换成删除度为1的节点
删除调整情况：（x是双重黑节点）
1.双重黑节点的兄弟节点是黑色，并且双重黑色的兄弟节点的子节点都为黑色
  • 调整方法： 给父节点加上一重黑，其左右子树减去一重黑。
43：黑/红->双重黑/黑        9：黑->红        95：双重黑->黑
2.双重黑的兄弟节点为黑色，并在右侧，其右子树（记为a）为红色（RR型失衡）
  • RR类型的判断优先级高于RL类型
  • 调整方法：先抓着双重黑节点的父节点大左旋，再将双重黑节点的 兄弟节点的颜色变成原父节点的颜色，原父节点和a（旋转后的根节点的左右子节点）的颜色变成黑色，双重黑节点变成黑色。
3.双重黑的兄弟节点为黑色，并在左侧，其左子树（记为a）为红色（LL型失衡）
  • LL类型的判断优先级高于LR类型
  • 调整方法：先抓着双重黑节点的父节点大右旋，再将双重黑节点的 兄弟节点的颜色变成原父节点的颜色，原父节点和a（旋转后的根节点的左右子节点）的颜色变成黑色，双重黑节点变成黑色。
4.双重黑的兄弟节点为黑色，并在右侧，其左子树（记为b）为红色，且右子树为黑色（RL型失衡）
  • 调整方法：先抓着双重黑节点的兄弟节点小右旋，转换成RR型失衡
5.双重黑的兄弟节点为黑色，并在左侧，其右子树（记为b）为红色，且左子树为黑色（LR型失衡）
  • 调整方法：先抓着双重黑节点的兄弟节点小左旋，转换成LL型失衡
6.双重黑节点的兄弟节点为红色，且位于右侧
  • 调整方法：抓着双重黑节点的父节点大左旋，原根节点修改成红色，新根节点修改成黑色，再次构成情况1/2/3/4/5, 递归到左子树去处理；
蓝框表示节点颜色确定；
7.双重黑节点的兄弟节点为红色，且位于左侧
  • 调整方法：抓着双重黑节点的父节点大右旋，原根节点修改成红色，新根节点修改成黑色，再次构成情况1/2/3/4/5， 递归到右子树去处理；
代码演示：
#include <string>
#include <vector>
#include <iostream>
#include <cinttypes>
#include <iostream>
#include <ctime>
#include <cstdio>
using namespace std;
#define RED     0
#define BLACK   1
#define DBLACK 2
#define NIL (&__NIL)
#define K (n) (n->key)
#define L (n) (n->lchild)
#define R (n) (n->rchild)
#define C (n) (n->color)
typedef struct Node {
        int key, color; // 0 red, 1 black, 2 double black;
        struct Node *rchild, *lchild;
} Node ;
Node __NIL;
void init_NIL() {
        NIL ->key = -1;
        NIL ->rchild = NIL ->lchild = NIL ;
        NIL ->color = BLACK ;
        return ;
}
//为保证相同路径的黑色节点数目相同，新生成的节点为红色
Node * getNewNode( int key ) {
        Node * p = ( Node *)malloc( sizeof ( Node ));
       p->key = key ;
       p->color = RED ;
       p->rchild = p->lchild = NIL ;
        return p;
}
//判断左右子树是否有红色
bool has_red_node( Node * root ) {
        return root ->lchild->color == RED || root ->rchild->color == RED ;
}
//左旋
Node * left_rotate( Node * root ) {
        Node * new_root = root ->rchild;
        root ->rchild = new_root->lchild;
       new_root->lchild = root ;
        return new_root;
}
//右旋
Node * right_rotate( Node * root ) {
        Node * new_root = root ->lchild;
        root ->lchild = new_root->rchild;
       new_root->rchild = root ;
        return new_root;
}
//插入调整
Node * insert_maintain( Node * root ) {
        int flag = 0;
        //判断祖父节点是否为LL/R型(情况2/3)
        if ( C ( L ( root )) == RED && has_red_node( L ( root ))) flag = 1;
        //判断祖父节点是否为RR/L型(情况4/5)
        if ( C ( R ( root )) == RED && has_red_node( R ( root ))) flag = 2;
        //没有出现红色节点的子节点也是红色的情况
        if (flag == 0) return root ;
        //
        if ( C ( L ( root )) == RED && C ( R ( root )) == RED ) goto red_up_maintain;
        if (flag == 1) {
               //LR型判断
               if ( C ( R ( L ( root ))) == RED ) {
                       //小左旋
                       L ( root ) = left_rotate( L ( root ));
              }
               //大右旋
               root = right_rotate( root );
       }
        else {
               //RL型判断
               if ( C ( L ( R ( root ))) == RED ) {
                       //小右旋
                       R ( root ) = right_rotate( R ( root ));
              }
               //大左旋
               root = left_rotate( root );
       }
red_up_maintain:
        C ( root ) = RED ;
        C ( L ( root )) = C ( R ( root )) = BLACK ;
        return root ;
}
//插入
Node * __insert( Node * root , int key ) {
        if ( root == NIL ) return getNewNode( key );
        if ( root ->key == key ) return root ;
        if ( key < root ->key) root ->lchild = __insert( root ->lchild, key );
        else root ->rchild = __insert( root ->rchild, key );
        //插入调整
        return insert_maintain( root );
}
Node * insert( Node * root , int key ) {
        //封装插入功能;
        root = __insert( root , key );
        //保证根节点是黑色
        root ->color = BLACK ;
        return root ;
}
//寻找根节点的前驱
Node * predecessor( Node * root ) {
        Node * temp = root ->lchild;
        while (temp->rchild != NIL )temp = temp->rchild;
        return temp;
}
Node * erase_maintain( Node * root ) {
        if ( C ( L ( root )) != DBLACK && C ( R ( root )) != DBLACK ) return root ;
    //双重黑节点的兄弟节点是红色
        if (has_red_node( root )) {
               //原根节点变成红色
               root ->color = RED ;
               //情况7
               if ( root ->lchild->color == RED ) {
                       root = right_rotate( root );
                       //递归到右子树进行删除调整
                       root ->rchild = erase_maintain( root ->rchild);
              }
               //情况6
               else {
                       root = left_rotate( root );
                       //递归到左子树进行删除调整
                       root ->lchild = erase_maintain( root ->lchild);
              }
               //原红色兄弟节点变成黑色
               root ->color = BLACK ;
               return root ;
       }
        if (( root ->lchild->color == DBLACK && !has_red_node( root ->rchild))
              || ( root ->rchild->color == DBLACK && !has_red_node( root ->lchild))) {
               root ->color += 1;
               root ->lchild->color -= 1;
               root ->rchild->color -= 1;
               return root ;
       }
        if ( root ->rchild->color == DBLACK ) {
               //双重黑节点变成黑色
               root ->rchild->color = BLACK ;
               //LR型失衡
               if ( root ->lchild->lchild->color != RED ) {
                       root ->lchild = left_rotate( root ->lchild);
              }
               //LL型失衡
               root ->lchild->color = root ->color;
               root = right_rotate( root );
       }
        else {
               //双重黑节点变成黑色
               root ->lchild->color = BLACK ;
               //RL型失衡
               if ( root ->rchild->rchild->color != RED ) {
                       root ->rchild = right_rotate( root ->rchild);
              }
               //LL型失衡
               root ->rchild->color = root ->color;
               root = left_rotate( root );
       }
        //旋转后的根节点的左右子节点的颜色变成黑色
        root ->lchild->color = root ->rchild->color = BLACK ;
        return root ;
}
//删除操作
Node * __erase( Node * root , int key ) {
        if ( root == NIL ) return root ;
        if ( key < root ->key) {
               root ->lchild = __erase( root ->lchild, key );
       }
        else if ( key > root ->key) {
               root ->rchild = __erase( root ->rchild, key );
       }
        else {
               //度为0/1的删除情况
               if ( root ->lchild == NIL || root ->rchild == NIL ) {
                       Node * temp = root ->lchild == NIL ? root ->rchild : root ->lchild;
                      temp->color += root ->color;
                      free( root );
                       return temp;
              }
               //度为2的删除情况--转换为度为1/0的删除情况
               Node * temp = predecessor( root );
               root ->key = temp->key;
               root ->lchild = __erase( root ->lchild, temp->key);
       }
        //删除调整
        return erase_maintain( root );
}
//封装删除操作
Node * erase( Node * root , int key ) {
        root = __erase( root , key );
        root ->color = BLACK ;
        return root ;
}
void clear( Node * root ) {
        if ( root == NIL ) return ;
       clear( root ->lchild);
       clear( root ->rchild);
       free( root );
        return ;
}
void output( Node * root ) {
        if ( root == NIL ) return ;
       printf( "(%d| %d; %d, %d)\n" ,
               C ( root ), K ( root ),
               K ( L ( root )), K ( R ( root ))
       );
       output( root ->lchild);
       output( root ->rchild);
        return ;
}
int main() {
       init_NIL();
       srand(time(0));
#define MAX_N 10
        Node * root = NIL ;
        for ( int i = 0; i < MAX_N ; i++) {
               int x = rand() % 100;
              printf( "\ninsert %d to red black tree : \n" , x);
              root = insert(root, x);
              output(root);
       }
        int x;
        while (~scanf_s( "%d" , &x)) {
              printf( "\nerase %d from red black tree\n" , x);
              root = erase(root, x);
              output(root);
       }
        return 0;
}

四，B-树

⼀棵 m 阶 B 树，需要满 ⾜下列特性： 
1. 树中每个节点，最多含有 m 棵 ⼦树 
2. 若 根节点不是叶 ⼦节点，则 ⾄少有 2 棵 ⼦树 
3. 除根结点之外的所有非终端结点 ⾄少有⌈m/2⌉棵 ⼦树 （⌈m/2⌉表示m/2向上取整）
4. 如果⼀个结点有n-1个关键字，则该结点有n个分支，且这n-1个关键字按照递增顺序排列 
5. 每个结点的结构为：( n，A0，K1，A1，K2，A2，… ，Kn，An ) 
  • n：节点数量
  • A0 ~ An：分支
  • K1~Kn：节点
  • 节点分支的关系： 例如：A0< K1, K1 < A1 < K2,  K2 < A2 < K3 ..... An > Kn
6. 非根结点中关键字的个数 n，满 ⾜ ：⌈m/2⌉-1 ≤ n ≤ m-1 -->平衡条件关键
7. 所有叶 ⼦节点处在同⼀层
m 阶 B 树的性质解读： 
    1. B 树中只有根节点没办法满⾜拥有⾄少 ⌈m/2⌉ 棵⼦树的条件，其他节点均能满⾜
    2. B 树是⼀种 ⾼度平衡的树形结构，比 AVL 树结构上更优美
插入操作：
证明：节点分裂的合理性
非根结点中关键字的个数 n，满 ⾜：⌈m/2⌉-1 ≤ n ≤ m-1 
当m = 2n + 1
⌈m/2⌉-1 = n;
分裂后：
左子树节点数：(m - 1) / 2 = n
右子树节点数：(m - 1) / 2 = n
当m = 2n
⌈m/2⌉-1 = n - 1;
分裂后：
左子树节点数：(m - 1 - 1) / 2 = n - 1
右子树节点数：(m - 1 + 1) / 2 = n
左右节点数均符合要求
删除操作：
m 阶 B 树的元素删除： 
    1. 终端节点直接删除 
    2. 非终端节点，与(前驱/后继)交换，再删除
代码演示：
#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
#include <ctime>
#include <cstdio>
using namespace std;
#define MAX_M 5
#define MAX_OP 15
typedef struct Node {
        //节点数量
        int n;
        //节点值
        int key[ MAX_M + 1];
        //分支
        struct Node * next[ MAX_M + 1];
} Node ;
Node * getNewNode() {
        Node * p = ( Node *)malloc( sizeof ( Node ));
       p->n = 0;
        //分支数组初始化为NULL
       memset(p->next, 0, sizeof ( Node *) * ( MAX_M + 1));
        return p;
}
//插入操作
//插入调整
Node * insert_maintain( Node * root , Node * child , int pos ) {
        //关键值数没有超过MAX_M
        if ( child ->n < MAX_M ) return root ;
        //要提取的关键值位置
        int spos = MAX_M / 2;
        //分裂成的两个小节点
        Node * node1 = getNewNode();
        Node * node2 = getNewNode();
       node1->n = spos;
       node2->n = MAX_M - 1 - spos;
        //node1的赋值
        for ( int i = 0; i < spos; i++) {
              node1->key[i] = child ->key[i];
              node1->next[i] = child ->next[i];
       }
       node1->next[spos] = child ->next[spos];
        //node2的赋值
        for ( int i = 0; i < node2->n; i++) {
              node2->key[i] = child ->key[i + spos + 1];
              node2->next[i] = child ->next[i + spos + 1];
       }
       node2->next[node2->n] = child ->next[ child ->n];
        //i = root->n 简化了代码
        for ( int i = root ->n; i >= pos ; i--) {
               root ->key[i + 1] = root ->key[i];
               root ->next[i + 1] = root ->next[i];
       }
        root ->key[ pos ] = child ->key[spos];
        root ->next[ pos ] = node1;
        root ->next[ pos + 1] = node2;
        root ->n += 1;
       free( child );
        return root ;
}
Node * insert_key( Node * root , int key ) {
        //根节点为空
        if ( root == NULL ) {
               root = getNewNode();
               root ->key[( root ->n)++] = key ;
               return root ;
       }
        //插入终端节点
        int pos = 0;
        //查找要插入的位置
        while (pos < root ->n && root ->key[pos] < key ) pos += 1;
        if (pos < root ->n && root ->key[pos] == key ) return root ;
        for ( int i = root ->n - 1; i >= pos; i--) {
               root ->key[i + 1] = root ->key[i];
       }
        root ->key[pos] = key ;
        root ->n += 1;
        return root ;
}
Node * __insert( Node * root , int key ) {
        // 根节点为空   || 当前节点为终端节点
        if ( root == NULL || root ->next[0] == NULL ) {
               return insert_key( root , key );
       }
        int pos = 0;
        while (pos < root ->n && root ->key[pos] < key ) pos += 1;
        //判断key是否已经存在
        if (pos < root ->n && root ->key[pos] == key ) return root ;
        //向next[pos]分支遍历
       __insert( root ->next[pos], key );
        return insert_maintain( root , root ->next[pos], pos);
}
Node * insert( Node * root , int key ) {
        root = __insert( root , key );
        //因为插入调整从父节点往下看
        //所以当根节点满了，要单独调整
        if ( root ->n == MAX_M ) {
               //生成空的新根节点
               Node * p = getNewNode();
              p->next[0] = root ;
               root = insert_maintain(p, root , 0);
       }
        return root ;
}
void clear( Node * root ) {
        if ( root == NULL ) return ;
        for ( int i = 0; i <= root ->n; i++) {
              clear( root ->next[i]);
       }
       free( root );
        return ;
}
void print_node( Node * root ) {
       printf( "%d : " , root ->n);
        for ( int i = 0; i < root ->n; i++) {
              printf( "%4d" , root ->key[i]);
       }
       printf( " | " );
        if ( root ->next[0] == NULL ) goto output_end;
        for ( int i = 0; i <= root ->n; i++) {
              printf( "%4d" , root ->next[i]->key[0]);
       }
output_end:
       printf( "\n" );
        return ;
}
void output( Node * root ) {
        if ( root == NULL ) return ;
       print_node( root );
        for ( int i = 0; i <= root ->n; i++) {
              output( root ->next[i]);
       }
        return ;
}
int main() {
       srand(time(0));
        Node * root = NULL ;
        for ( int i = 0; i < MAX_OP ; i++) {
               int val = rand() % 100;
              root = insert(root, val);
              printf( "\ninsert %d to BTree : \n" , val);
              output(root);
       }
        return 0;
}
左旋/右旋：
左子树富裕--右旋，右子树富裕--左旋，
合并：

代码演示：
#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
#include <ctime>
#include <cstdio>
using namespace std;
#define MAX_M 3
#define MAX_OP 12
#define LCHILD (root, pos) (root->next[pos])
#define RCHILD (root, pos) (root->next[pos + 1])
#define LAST_KEY (root) (root->key[root->n - 1])
#define LAST_CHILD (root) (root->next[root->n])
typedef struct Node {
        //关键字数量
        int n;
        //关键字值
        int key[ MAX_M + 1];
        //分支
        struct Node * next[ MAX_M + 1];
} Node ;
Node * getNewNode() {
        Node * p = ( Node *)malloc( sizeof ( Node ));
       p->n = 0;
        //分支数组初始化为NULL
       memset(p->next, 0, sizeof ( Node *) * ( MAX_M + 1));
        return p;
}
//插入操作
//插入调整
Node * insert_maintain( Node * root , Node * child , int pos ) {
        //关键值数没有超过MAX_M
        if ( child ->n < MAX_M ) return root ;
        //要提取的关键值位置
        int spos = MAX_M / 2;
        //分裂成的两个小节点
        Node * node1 = getNewNode();
        Node * node2 = getNewNode();
       node1->n = spos;
       node2->n = MAX_M - 1 - spos;
        //node1的赋值
        for ( int i = 0; i < spos; i++) {
              node1->key[i] = child ->key[i];
              node1->next[i] = child ->next[i];
       }
       node1->next[spos] = child ->next[spos];
        //node2的赋值
        for ( int i = 0; i < node2->n; i++) {
              node2->key[i] = child ->key[i + spos + 1];
              node2->next[i] = child ->next[i + spos + 1];
       }
       node2->next[node2->n] = child ->next[ child ->n];
        //i = root->n 简化了代码
        for ( int i = root ->n; i >= pos ; i--) {
               root ->key[i + 1] = root ->key[i];
               root ->next[i + 1] = root ->next[i];
       }
        root ->key[ pos ] = child ->key[spos];
        root ->next[ pos ] = node1;
        root ->next[ pos + 1] = node2;
        root ->n += 1;
       free( child );
        return root ;
}
Node * insert_key( Node * root , int key ) {
        //根节点为空
        if ( root == NULL ) {
               root = getNewNode();
               root ->key[( root ->n)++] = key ;
               return root ;
       }
        //插入终端节点
        int pos = 0;
        //查找要插入的位置
        while (pos < root ->n && root ->key[pos] < key ) pos += 1;
        if (pos < root ->n && root ->key[pos] == key ) return root ;
        for ( int i = root ->n - 1; i >= pos; i--) {
               root ->key[i + 1] = root ->key[i];
       }
        root ->key[pos] = key ;
        root ->n += 1;
        return root ;
}
Node * __insert( Node * root , int key ) {
        // 根节点为空   || 当前节点为终端节点
        if ( root == NULL || root ->next[0] == NULL ) {
               return insert_key( root , key );
       }
        int pos = 0;
        while (pos < root ->n && root ->key[pos] < key ) pos += 1;
        //判断key是否已经存在
        if (pos < root ->n && root ->key[pos] == key ) return root ;
        //向next[pos]分支遍历
       __insert( root ->next[pos], key );
        return insert_maintain( root , root ->next[pos], pos);
}
Node * insert( Node * root , int key ) {
        root = __insert( root , key );
        //因为插入调整从父节点往下看
        //所以当根节点满了，要单独调整
        if ( root ->n == MAX_M ) {
               //生成空的新根节点
               Node * p = getNewNode();
              p->next[0] = root ;
               root = insert_maintain(p, root , 0);
       }
        return root ;
}
//删除操作
void erase_pos( Node * root , int pos ) {
        for ( int i = pos + 1; i < root ->n; i++) {
               root ->key[i - 1] = root ->key[i];
       }
        root ->n -= 1;
        return ;
}
//删除调整
//右旋
void right_rotate( Node * root , int pos ) {
        for ( int i = RCHILD ( root , pos )->n + 1; i > 0; i--) {
               RCHILD ( root , pos )->key[i] = RCHILD ( root , pos )->key[i - 1];
               RCHILD ( root , pos )->next[i] = RCHILD ( root , pos )->next[i - 1];
       }
        RCHILD ( root , pos )->key[0] = root ->key[ pos ];
        root ->key[ pos ] = LAST_KEY ( LCHILD ( root , pos ));
        RCHILD ( root , pos )->next[0] = LAST_CHILD ( LCHILD ( root , pos ));
        LAST_CHILD ( LCHILD ( root , pos )) = NULL ;
        RCHILD ( root , pos )->n += 1;
        LCHILD ( root , pos )->n -= 1;
        return ;
}
//左旋
void left_rotate( Node * root , int pos ) {
        LCHILD ( root , pos )->key[ LCHILD ( root , pos )->n] = root ->key[ pos ];
        LCHILD ( root , pos )->n += 1;
        root ->key[ pos ] = RCHILD ( root , pos )->key[0];
        LAST_CHILD ( LCHILD ( root , pos )) = RCHILD ( root , pos )->next[0];
        for ( int i = 0; i < RCHILD ( root , pos )->n; i++) {
               RCHILD ( root , pos )->key[i] = RCHILD ( root , pos )->key[i + 1];
               RCHILD ( root , pos )->next[i] = RCHILD ( root , pos )->next[i + 1];
       }
        LAST_CHILD ( RCHILD ( root , pos )) = NULL ;
        RCHILD ( root , pos )->n -= 1;
        return ;
}
void merge_node( Node * root , int pos ) {
        Node * node = getNewNode();
        //拷贝pos左分支
        for ( int i = 0; i <= LCHILD ( root , pos )->n; i++) {
              node->key[i] = LCHILD ( root , pos )->key[i];
              node->next[i] = LCHILD ( root , pos )->next[i];
       }
        //拷贝root->key[pos]
       node->n = LCHILD ( root , pos )->n + 1;
       node->key[node->n - 1] = root ->key[ pos ];
        //拷贝pos右分支
        for ( int i = 0; i <= RCHILD ( root , pos )->n; i++) {
              node->key[i + node->n] = RCHILD ( root , pos )->key[i];
              node->next[i + node->n] = RCHILD ( root , pos )->next[i];
       }
       node->n += RCHILD ( root , pos )->n;
       free( LCHILD ( root , pos ));
       free( RCHILD ( root , pos ));
        for ( int i = pos + 1; i <= root ->n; i++) {
               root ->key[i - 1] = root ->key[i];
               root ->next[i - 1] = root ->next[i];
       }
        root ->next[ pos ] = node;
        root ->n -= 1;
        return ;
}
Node * erase_maintain( Node * root , int pos ) {
        //最少关键字数
        int lower_bound = ( MAX_M + 1) / 2 - 1;
        if ( root ->next[ pos ]->n >= lower_bound) return root ;
        // root->next[pos]左边关键字富裕
        if ( pos > 0 && root ->next[ pos - 1]->n > lower_bound) {
               //拎着pos - 1节点右旋
              right_rotate( root , pos - 1);
       }
        // root->next[pos]右边关键字富裕
        else if ( pos < root ->n && root ->next[ pos + 1]->n > lower_bound) {
               拎着pos节点左旋
              left_rotate( root , pos );
       }
        // root->next[pos]左右两边关键字都不富裕
        else {
               //pos > 0:向前合并
               if ( pos > 0) merge_node( root , pos - 1); // merge(i, j) -> (j, j + 1)
               //pos == 0 :向后合并
               else merge_node( root , pos );
       }
        return root ;
}
Node * __erase( Node * root , int key ) {
        if ( root == NULL ) return root ;
        int pos = 0;
        //找到大于或等于key的关键字的位置
        while (pos < root ->n && root ->key[pos] < key ) pos += 1;
        //当前节点为终端节点
        if ( root ->next[0] == NULL ) {
               if ( root ->key[pos] == key ) erase_pos( root , pos);
               return root ;
       }
        else {
               //找到key, 但不位于终端节点
               if (pos < root ->n && root ->key[pos] == key ) {
                       //查找key所在位置的前驱
                       //前驱位于终端节点
                       Node * temp = root ->next[pos];
                       while (temp->next[temp->n]) temp = temp->next[temp->n];
                       int val = temp->key[temp->n - 1];
                       //前驱与要删除位置交换-->把要删除的节点移到终端节点
                      swap( root ->key[pos], temp->key[temp->n - 1]);
              }
               //递归到终端节点删除key
               root ->next[pos] = __erase( root ->next[pos], key );
       }
        //pos为已删除关键字的分支
        return erase_maintain( root , pos);
}
Node * erase( Node * root , int key ) {
        root = __erase( root , key );
        //root的关键字数为0，将根节点的唯一子树作为新数根节点
        if ( root ->n == 0) {
               Node * temp = root ->next[0];
              free( root );
               root = temp;
       }
        return root ;
}
void clear( Node * root ) {
        if ( root == NULL ) return ;
        for ( int i = 0; i <= root ->n; i++) {
              clear( root ->next[i]);
       }
       free( root );
        return ;
}
void print_node( Node * root ) {
       printf( "%d : " , root ->n);
        for ( int i = 0; i < root ->n; i++) {
              printf( "%4d" , root ->key[i]);
       }
       printf( " | " );
        if ( root ->next[0] == NULL ) goto output_end;
        for ( int i = 0; i <= root ->n; i++) {
              printf( "%4d" , root ->next[i]->key[0]);
       }
output_end:
       printf( "\n" );
        return ;
}
void output( Node * root ) {
        if ( root == NULL ) return ;
       print_node( root );
        for ( int i = 0; i <= root ->n; i++) {
              output( root ->next[i]);
       }
        return ;
}
int main() {
       srand(time(0));
        Node * root = NULL ;
        for ( int i = 0; i < MAX_OP ; i++) {
               int val = rand() % 100;
              root = insert(root, val);
              printf( "\ninsert %d to BTree : \n" , val);
              output(root);
       }
        int x;
        while (~scanf_s( "%d" , &x)) {
              printf( "erase %d from BTree : \n" , x);
              root = erase(root, x);
              output(root);
       }
        return 0;
}
(╯▔皿▔)╯
关注
  • 22
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++写的平衡树数据结构
03-24
本项目涉及的是一个用C++实现的平衡树数据结构，特别关注于元素的添加和删除操作，以确保在这些操作后树仍然保持平衡。平衡树是一种特殊的二叉树，它的每个节点的两个子树高度差不超过1，这使得搜索、插入和删除等...
平衡树的建立 插入删除 等操作
07-14
平衡树是一种特殊的二叉树数据结构，其设计目标是保持树的高度平衡，从而在插入、删除和查找等操作中保持高效的性能。在计算机科学中，平衡树是解决动态集合问题的关键工具之一，尤其是在大量数据处理时。本篇将详细...
平衡树大全
10-05
在《BST_拓展与伸展树_(Splay)_一日通.pdf》中，你可以找到关于Splay树基础概念、伸展操作和各种变种（如zig-zag、zig-zig、zig-zag-zig等）的详细解释。 2. **Treap树**： Treap是树和堆的结合体，它通过在每个...
C++实现平衡树的问题
01-08
总的来说，理解和实现C++中的平衡树涉及基础数据结构知识、递归思维、以及对平衡策略的理解。通过练习和学习，我们可以熟练掌握这些技能，为更复杂的数据结构和算法打下坚实的基础。在实际项目中，平衡树常被用于...
二叉平衡树学生管理系统
09-11
以上就是“二叉平衡树学生管理系统”涉及的主要技术点和实现细节，每一个部分都需要扎实的理论基础和实践经验。通过学习和实践这个项目，开发者可以深化对数据结构、文件操作和C语言编程的理解，提升软件开发能力。
C++笔记5•内存管理•
qq_64446190的博客
08-12 1100
内存管理
C语言 | Leetcode C语言题解之第337题打家劫舍III
最新发布
m0_59237910的博客
08-15 158
C语言 | Leetcode C语言题解之第337题打家劫舍III
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 212
C++ | Leetcode C++题解之第337题打家劫舍III
【C语言】字符串操作函数详解
EleganceJiaBao的博客
08-14 917
这些头文件提供了字符串操作所需的函数声明。以下是常用字符串操作函数的详细讲解，包括每个函数的参数、返回值说明以及示例代码。每个函数的使用说明还包括了适当的表格以帮助理解其功能和用法。
C++笔记4•类和对象3•
qq_64446190的博客
08-12 665
类和对象3
C++STL详解（六）——list类的具体实现
duanku111的博客
08-14 776
list的迭代器类，实际上只是对结点的指针进行了封装，并对其各个操作符进行了重载，使得结点指针的各种行为看起来和普通指针一样。
1 基本概念
m0_62280492的博客
08-13 573
C语言基本概念
【Markdown】Markdown 中的语言简称
EleganceJiaBao的博客
08-12 927
以下是常见编程语言、脚本语言、标记语言等在 Markdown 中的语言简称以及相应的示例：
typdef 与 struct
ligreenjian的博客
08-14 85
int age;int num;//每使用一次就要多一个struct。使用typdef就简洁些。
C++_基本语法笔记_继承和多态
qq_45629864的博客
08-13 542
思想与Java差不多。
C语言常用关键字
Fearlessness的博客
08-14 470
C语言中常用的关键字
【CPP】CPP的STL(前篇)
2302_79981653的博客
08-12 788
简单来说:CPP在有了模板之后,很多重复性质的代码就不需要自己手撕很多遍了,甚至说有前人做了一个库,把常见的算法,数据结构啥的放进库里面,这些数据结构,算法啥的全都采用了模板类和模板函数的形式,使得这个库里的代码复用率极高,况且写这个库的人都是大佬级别的大佬,效率也很不错,所以在CPP实际开发中,就不需要自己再造轮子了,调用这个库里的玩意就行STL目前有两个需要去学习的版本,一个是微软家的PJ版,一个是GCC(Linux)的SGI版,这俩调用的效果都是一样的,只是底层不一样,需要了解一下。
每日OJ_牛客HJ75 公共子串计算
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
08-12 525
每日OJ_牛客HJ75 公共子串计算（求最大公共子串，使用递推实现 假设 x(i)：字符串第i个字符 y(j)：字符串第j个字符 dp[i][j]：以x(i)，y(j)结尾的最大子串长度。比如：x: "abcde" y:"bcdae" dp[2][1]：以x(2)，y(1)结尾的最大子串长度即：x遍历到"abc"，y遍历 到"bc"，都以字符'c'结尾时最大公共子串为"bc"）
【C++】C++的内存处理 --- 智能指针
JLX_1的博客
08-12 1107
本文探讨了C++智能指针的原理与应用，分析了传统异常机制中内存泄漏问题，并提出智能指针的解决方案。文章详细介绍了RAII技术、shared_ptr、unique_ptr和weak_ptr的使用，并演示了如何通过自定义删除器来适配不同的资源释放需求。同时，文章还提及了多线程环境下智能指针的安全性和内存泄漏问题，强调智能指针在预防内存泄漏中的重要作用，为C++开发者提供了实用的内存管理指南。
二叉排序树与二叉平衡树
03-20
二叉排序树（Binary Search Tree，BST）是一种特殊的二叉树结构，它满足以下性质： 1. 左子树上的所有节点的值都小于根节点的值。 2. 右子树上的所有节点的值都大于根节点的值。 3. 左右子树也分别为二叉排序树。 通过这种结构，我们可以快速地进行查找、插入和删除操作。对于查找操作，我们可以通过比较目标值与当前节点的值，来确定向左子树还是右子树进行查找。对于插入和删除操作，我们需要保持二叉排序树的性质不变。 二叉平衡树（Balanced Binary Tree）是一种特殊的二叉排序树，它在保持二叉排序树性质的基础上，还具有以下性质： 1. 左右子树的高度差不超过1。 2. 左右子树也分别为二叉平衡树。 通过保持平衡性，二叉平衡树可以避免出现极端情况下的不平衡现象，从而提高了查找、插入和删除操作的效率。常见的二叉平衡树有AVL树、红黑树等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值