Size Balance Tree(SBT模板整理)

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
/*
* tree[x].left   表示以 x 为节点的左儿子
* tree[x].right  表示以 x 为节点的右儿子
* tree[x].size   表示以 x 为根的节点的个数(大小)
*/
 
 
struct SBT
{
    int key,left,right,size;
} tree[10010];
int root = 0,top = 0;
 
void left_rot(int &x)         // 左旋
{
    int y = tree[x].right;
    if (!y) return;
    tree[x].right = tree[y].left;
    tree[y].left = x;
    tree[y].size = tree[x].size;
    tree[x].size = tree[tree[x].left].size + tree[tree[x].right].size + 1;
    x = y;
}
 
void right_rot(int &x)        //右旋
{
    int y = tree[x].left;
    if (!y) return;
    tree[x].left = tree[y].right;
    tree[y].right = x;
    tree[y].size = tree[x].size;
    tree[x].size = tree[tree[x].left].size + tree[tree[x].right].size + 1;
    x = y;
}
 
void maintain(int &x,bool flag)  //维护SBT状态
{
    if (!x) return;
    if (flag == false)           //左边
    {
        if(tree[tree[tree[x].left].left].size > tree[tree[x].right].size)//左孩子的左孩子大于右孩子
            right_rot(x);
        else if (tree[tree[tree[x].left].right].size > tree[tree[x].right].size) //左孩子的右孩子大于右孩子
        {
            left_rot(tree[x].left);
            right_rot(x);
        }
        else
            return;
    }
    else                       //右边
    {
        if(tree[tree[tree[x].right].right].size > tree[tree[x].left].size)//右孩子的右孩子大于左孩子
            left_rot(x);
        else if(tree[tree[tree[x].right].left].size > tree[tree[x].left].size) //右孩子的左孩子大于左孩子
        {
            right_rot(tree[x].right);
            left_rot(x);
        }
        else
            return;
    }
    maintain(tree[x].left,false);
    maintain(tree[x].right,true);
    maintain(x,true);
    maintain(x,false);
}
 
void insert(int &x,int key)  //插入
{
    if (x == 0)
    {
        x = ++top;
        tree[x].left = 0;
        tree[x].right = 0;
        tree[x].size = 1;
        tree[x].key = key;
    }
    else
    {
        tree[x].size++;
        if(key < tree[x].key)
            insert(tree[x].left,key);
        else
            insert(tree[x].right,key);//相同元素可插右子树
        maintain(x,key >= tree[x].key);
    }
}
 
int remove(int &x,int key)  //利用后继删除
{
    tree[x].size--;
    if(key > tree[x].key)
        remove(tree[x].right,key);
    else  if(key < tree[x].key)
        remove(tree[x].left,key);
    else  if(tree[x].left !=0 && !tree[x].right) //有左子树,无右子树
    {
        int tmp = x;
        x = tree[x].left;
        return tmp;
    }
    else if(!tree[x].left && tree[x].right != 0) //有右子树,无左子树
    {
        int tmp = x;
        x = tree[x].right;
        return tmp;
    }
    else if(!tree[x].left && !tree[x].right)    //无左右子树
    {
        int tmp = x;
        x = 0;
        return tmp;
    }
    else                                      //左右子树都有
    {
        int tmp = tree[x].right;
        while(tree[tmp].left)
            tmp = tree[tmp].left;
        tree[x].key = tree[temp].key;
        remove(tree[x].right,tree[tmp].key);
    }
}
 
int getmin(int x)    //求最小值
{
    while(tree[x].left)
        x = tree[x].left;
    return tree[x].key;
}
 
int getmax(int x)    //求最大值
{
    while(tree[x].right)
        x = tree[x].right;
    return tree[x].key;
}
 
int pred(int &x,int y,int key)   //前驱,y初始前驱,从0开始, 最终要的是返回值的key值
{
    if(x == 0)
        return y;
    if(key > tree[x].key)
        return pred(tree[x].right,x,key);
    else
        return pred(tree[x].left,y,key);
}
 
int succ(int &x,int y,int key)   //后继,同上
{
    if(x == 0)
        return y;
    if(key < tree[x].key)
        return succ(tree[x].left,x,key);
    else
        return succ(tree[x].right,y,key);
}
 
int select(int &x,int k)   //查找第k小的数
{
    int r = tree[tree[x].left].size + 1;
    if(r == k)
        return tree[x].key;
    else if(r < k)
        return select(tree[x].right,k - r);
    else
        return select(tree[x].left,k);
}
 
int rank(int &x,int key)   //key排第几
{
    if(key < tree[x].key)
    {
        return rank(tree[x].left,key);
    }
    else if(key > tree[x].key)
        return rank(tree[x].right,key) + tree[tree[x].left].size + 1;
    else
        return tree[tree[x].left].size + 1;
}
 
int main()
{
    //insert(root,key);
    //delete(root,key)
    return 0;
}

详情查看陈启峰的论文

posted @   zxzhang  阅读(494)  评论(0编辑  收藏  举报
编辑推荐:
· 基于Microsoft.Extensions.AI核心库实现RAG应用
· Linux系列:如何用heaptrack跟踪.NET程序的非托管内存泄露
· 开发者必知的日志记录最佳实践
· SQL Server 2025 AI相关能力初探
· Linux系列:如何用 C#调用 C方法造成内存泄露
阅读排行:
· 震惊!C++程序真的从main开始吗?99%的程序员都答错了
· 别再用vector<bool>了!Google高级工程师:这可能是STL最大的设计失误
· 单元测试从入门到精通
· 【硬核科普】Trae如何「偷看」你的代码?零基础破解AI编程运行原理
· 上周热点回顾(3.3-3.9)
点击右上角即可分享
微信分享提示