红黑树

最新推荐文章于 2024-09-04 21:14:17 发布
最新推荐文章于 2024-09-04 21:14:17 发布
阅读量74 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/strawberryfgalois/p/4127529.html
版权

1、RBT

#include "stdafx.h"
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<iostream>
#define maxn 1111111
#define RED 0
#define BLACK 1
#define nil 0
using namespace std;
int n, m,id,value, root, tot, lefts[maxn], rights[maxn], fa[maxn], key[maxn], color[maxn], bh[maxn],size[maxn];
void init()
{
    root = 0;
    lefts[nil] = rights[nil] = nil;
    fa[nil] = nil; //father of the node
    color[nil] = BLACK;
    size[nil] = 0;
    bh[nil] = 1;
}
void update(int x)
{
    if (x == nil) return;
    size[x] = size[lefts[x]] + size[rights[x]] + 1;
}
void LR(int x)
{
    int y = rights[x];
    rights[x] = lefts[y];
    if (lefts[y] != nil) fa[lefts[y]] = x;
    fa[y] = fa[x];
    if (fa[x] == nil) root = y; //no one node points to y
    else if (x == lefts[fa[x]]) lefts[fa[x]] = y;
    else rights[fa[x]] = y;
    fa[x] = y;
    lefts[y] = x;
    update(x);
    update(y);
}
void RR(int x)
{
    int y = lefts[x];
    lefts[x] = rights[y];
    if (rights[y] != nil) fa[rights[y]] = x;
    fa[y] = fa[x];
    if (fa[x] == nil) root = y; //no one node points to y
    else if (x == lefts[fa[x]]) lefts[fa[x]] = y;
    else rights[fa[x]] = y;
    fa[x] = y;
    rights[y] = x;
    update(x);
    update(y);
}
void insertfixup(int z)
{
    while (color[fa[z]] == RED) // fa[z] cannot be the root since color[root]=BLACK always;
    {
        if (fa[z] == lefts[fa[fa[z]]])
        {
            int w = rights[fa[fa[z]]];
            if (color[w] == RED)
            {
                color[fa[z]] = color[w] = BLACK;
                color[fa[fa[z]]] = RED;
                z = fa[fa[z]]; //color[z]=RED; only this case changes the value of z
            }
            else //color[w]==BLACK;
            {
                if (z == rights[fa[z]]) { z = fa[z]; LR(z); } //leftsrotate(z)   so that z==lefts[fa[z]] 
                color[fa[z]] = BLACK;
                color[fa[fa[z]]] = RED;
                RR(fa[fa[z]]);    //once it is implementated it will break out of the while loop 
                //so there are at most two rotatation LR & RR    
            }
        }
        else //fa[z]==rights[fa[fa[z]]]
        {
            int w = lefts[fa[fa[z]]];
            if (color[w] == RED)
            {
                color[fa[z]] = color[w] = BLACK;
                color[fa[fa[z]]] = RED;
                z = fa[fa[z]]; //color[z]=RED;
            }
            else //color[w]==BLACK
            {
                if (z == lefts[fa[z]]) { z = fa[z]; RR(z); }
                color[fa[z]] = BLACK;
                color[fa[fa[z]]] = RED;
                LR(fa[fa[z]]);
            }
        }
    }
    color[root] = BLACK; //maintain ROOT BLACK
}
void insert(int v)
{
    int y = nil;
    int x = root;
    while (x != nil)
    {
        size[x]++;
        y = x;
        if (v < key[x]) x = lefts[x]; else x = rights[x];
    }
    fa[++tot] = y; lefts[tot] = rights[tot] = nil;;
    key[tot] = v; size[tot] = 1;
    if (y == nil) root = tot;
    else if (v < key[y]) lefts[y] = tot; else rights[y] = tot;
    color[tot] = RED; //red 
    insertfixup(tot);
}
int findmin(int x)
{
    while (lefts[x] != nil) x = lefts[x];
    return x;
}
int succ(int x)
{
    if (rights[x] != nil) return findmin(rights[x]);
    int y = fa[x];
    while (y != nil && x == rights[y])
    {
        x = y;
        y = fa[y];
    }
    return y;
}
void deletesfixup(int z)
{
    while (z != root && color[z] == BLACK) //REDBLACK || BLACKBLACK EXIT
    {
        if (z == lefts[fa[z]])
        {
            int w = rights[fa[z]];
            if (color[w] == RED)
            {
                color[fa[z]] = RED;
                color[w] = BLACK;
                LR(fa[z]); //turns into case 2
                w = rights[fa[z]];
            }            
            if (color[lefts[w]] == BLACK && color[rights[w]] == BLACK)
            {                
                color[w] = RED;
                z = fa[z];
            }
            else
            {
                if (color[rights[w]] == BLACK) //RED BLACK  
                {
                    color[lefts[w]] = BLACK;
                    color[w] = RED; 
                    RR(w); //turns into case 4
                    w = rights[fa[z]]; 
                }
                //RIGHT RED
                color[w] = color[fa[z]];
                color[fa[z]] = BLACK;
                color[rights[w]] = BLACK;
                LR(fa[z]);
                z = root;
            }
        }
        else //z==rights[fa[z]]
        {
            int w = lefts[fa[z]];
            if (color[w] == RED)
            {
                color[fa[z]] = RED;
                color[w] = BLACK;
                RR(fa[z]); //turns into case 2
                w = lefts[fa[z]];
            }
            if (color[lefts[w]] == BLACK && color[rights[w]] == BLACK)
            {
                color[z] = BLACK;
                color[w] = RED;
                z = fa[z];
            }
            else
            {
                if (color[lefts[w]] == BLACK) //RED BLACK  
                {
                    color[rights[w]] = BLACK;
                     color[w] = RED;
                    LR(w); //turns into case 4
                    w = lefts[fa[z]];
                }
                //LEFT RED
                color[w] = color[fa[z]];
                color[fa[z]] = BLACK;
                color[lefts[w]] = BLACK;
                RR(fa[z]);
                z = root;
            }
        }
    }
    color[z] = BLACK;
}
void deletes(int z)
{
    int y;
    if (lefts[z] == nil || rights[z] == nil) y = z;
    else y = succ(z);
    int x;
    if (lefts[y] != nil) x = lefts[y]; else x = rights[y];
    fa[x] = fa[y];
    if (fa[y] == nil) root = x;
        else if (y == lefts[fa[y]]) lefts[fa[y]] = x; 
                else rights[fa[y]] = x;
    if (y != z) key[z] = key[y];
    int p = fa[x];
    while (p != nil) { size[p]--; p = fa[p]; }
    if (color[y] == BLACK) deletesfixup(x);
}
int getKth(int x, int now)
{
    if (size[lefts[x]] >= now) return getKth(lefts[x], now);
    if (size[lefts[x]] + 1 == now) return x;
    return getKth(rights[x], now - size[lefts[x]] - 1);
}
int _tmain(int argc, _TCHAR* argv[])
{
    freopen("RBT.in", "r", stdin);
    freopen("RBT.out", "w", stdout);
    init();
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
    {
        scanf("%d", &value);
        insert(value);
    }
    scanf("%d", &m);
    for (int i = 0; i < m; i++)
    {
        scanf("%d", &id);
        deletes(getKth(root,id));
    }
    return 0;
}

 

2、poj 1442

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<iostream>
#define maxn 1111111
#define RED 0
#define BLACK 1
#define nil 0
using namespace std;
int n, m,id,value, root, tot, lefts[maxn], rights[maxn], fa[maxn], key[maxn], color[maxn], size[maxn],p[maxn],rank[maxn],a[maxn],flag[maxn];
void init()
{
    root = 0;
    lefts[nil] = rights[nil] = nil;
    fa[nil] = nil; //father of the node
    color[nil] = BLACK;
    size[nil] = 0;
}
void update(int x)
{
    if (x == nil) return;
    size[x] = size[lefts[x]] + size[rights[x]] + 1;
}
void LR(int x)
{
    int y = rights[x];
    rights[x] = lefts[y];
    if (lefts[y] != nil) fa[lefts[y]] = x;
    fa[y] = fa[x];
    if (fa[x] == nil) root = y; //no one node points to y
    else if (x == lefts[fa[x]]) lefts[fa[x]] = y;
    else rights[fa[x]] = y;
    fa[x] = y;
    lefts[y] = x;
    update(x);
    update(y);
}
void RR(int x)
{
    int y = lefts[x];
    lefts[x] = rights[y];
    if (rights[y] != nil) fa[rights[y]] = x;
    fa[y] = fa[x];
    if (fa[x] == nil) root = y; //no one node points to y
    else if (x == lefts[fa[x]]) lefts[fa[x]] = y;
    else rights[fa[x]] = y;
    fa[x] = y;
    rights[y] = x;
    update(x);
    update(y);
}
void insertfixup(int z)
{
    while (color[fa[z]] == RED) // fa[z] cannot be the root since color[root]=BLACK always;
    {
        if (fa[z] == lefts[fa[fa[z]]])
        {
            int w = rights[fa[fa[z]]];
            if (color[w] == RED)
            {
                color[fa[z]] = color[w] = BLACK;
                color[fa[fa[z]]] = RED;
                z = fa[fa[z]]; //color[z]=RED; only this case changes the value of z
            }
            else //color[w]==BLACK;
            {
                if (z == rights[fa[z]]) { z = fa[z]; LR(z); } //leftsrotate(z)   so that z==lefts[fa[z]] 
                color[fa[z]] = BLACK;
                color[fa[fa[z]]] = RED;
                RR(fa[fa[z]]);    //once it is implementated it will break out of the while loop 
                //so there are at most two rotatation LR & RR    
            }
        }
        else //fa[z]==rights[fa[fa[z]]]
        {
            int w = lefts[fa[fa[z]]];
            if (color[w] == RED)
            {
                color[fa[z]] = color[w] = BLACK;
                color[fa[fa[z]]] = RED;
                z = fa[fa[z]]; //color[z]=RED;
            }
            else //color[w]==BLACK
            {
                if (z == lefts[fa[z]]) { z = fa[z]; RR(z); }
                color[fa[z]] = BLACK;
                color[fa[fa[z]]] = RED;
                LR(fa[fa[z]]);
            }
        }
    }
    color[root] = BLACK; //maintain ROOT BLACK
}
void insert(int v)
{
    int y = nil;
    int x = root;
    while (x != nil)
    {
        size[x]++;
        y = x;
        if (v < key[x]) x = lefts[x]; else x = rights[x];
    }
    fa[++tot] = y; lefts[tot] = rights[tot] = nil;;
    key[tot] = v; size[tot] = 1;
    if (y == nil) root = tot;
    else if (v < key[y]) lefts[y] = tot; else rights[y] = tot;
    color[tot] = RED; //red 
    insertfixup(tot);
}
int findmin(int x)
{
    while (lefts[x] != nil) x = lefts[x];
    return x;
}
int succ(int x)
{
    if (rights[x] != nil) return findmin(rights[x]);
    int y = fa[x];
    while (y != nil && x == rights[y])
    {
        x = y;
        y = fa[y];
    }
    return y;
}
void deletesfixup(int z)
{
    while (z != root && color[z] == BLACK) //REDBLACK || BLACKBLACK EXIT
    {
        if (z == lefts[fa[z]])
        {
            int w = rights[fa[z]];
            if (color[w] == RED)
            {
                color[fa[z]] = RED;
                color[w] = BLACK;
                LR(fa[z]); //turns into case 2
                w = rights[fa[z]];
            }            
            if (color[lefts[w]] == BLACK && color[rights[w]] == BLACK)
            {                
                color[w] = RED;
                z = fa[z];
            }
            else
            {
                if (color[rights[w]] == BLACK) //RED BLACK  
                {
                    color[lefts[w]] = BLACK;
                    color[w] = RED; 
                    RR(w); //turns into case 4
                    w = rights[fa[z]]; 
                }
                //RIGHT RED
                color[w] = color[fa[z]];
                color[fa[z]] = BLACK;
                color[rights[w]] = BLACK;
                LR(fa[z]);
                z = root;
            }
        }
        else //z==rights[fa[z]]
        {
            int w = lefts[fa[z]];
            if (color[w] == RED)
            {
                color[fa[z]] = RED;
                color[w] = BLACK;
                RR(fa[z]); //turns into case 2
                w = lefts[fa[z]];
            }
            if (color[lefts[w]] == BLACK && color[rights[w]] == BLACK)
            {
                color[z] = BLACK;
                color[w] = RED;
                z = fa[z];
            }
            else
            {
                if (color[lefts[w]] == BLACK) //RED BLACK  
                {
                    color[rights[w]] = BLACK;
                     color[w] = RED;
                    LR(w); //turns into case 4
                    w = lefts[fa[z]];
                }
                //LEFT RED
                color[w] = color[fa[z]];
                color[fa[z]] = BLACK;
                color[lefts[w]] = BLACK;
                RR(fa[z]);
                z = root;
            }
        }
    }
    color[z] = BLACK;
}
void deletes(int z)
{
    int y;
    if (lefts[z] == nil || rights[z] == nil) y = z;
    else y = succ(z);
    int x;
    if (lefts[y] != nil) x = lefts[y]; else x = rights[y];
    fa[x] = fa[y];
    if (fa[y] == nil) root = x;
        else if (y == lefts[fa[y]]) lefts[fa[y]] = x; 
                else rights[fa[y]] = x;
    if (y != z) key[z] = key[y];
    int p = fa[x];
    while (p != nil) { size[p]--; p = fa[p]; }
    if (color[y] == BLACK) deletesfixup(x);
}
int getKth(int x, int now)
{
    if (size[lefts[x]] >= now) return getKth(lefts[x], now);
    if (size[lefts[x]] + 1 == now) return key[x];
    return getKth(rights[x], now - size[lefts[x]] - 1);
}
int getnode(int v)
{
    int x=root;
    while (key[x]!=v)
    {
       if (v<key[x]) x=lefts[x]; else x=rights[x];
    }
    return x;
}
int main()
{
    init();
    scanf("%d %d", &n,&m);
    for (int i = 1; i <=n; i++)
    {
        scanf("%d",&a[i]);
    }
    for (int i=1;i<=m;i++) 
    {
        int v;
        scanf("%d",&v);
        flag[v]++;
    }
    int now=0;
    for (int i=1;i<=n;i++)
    {
        insert(a[i]);
        for (int j=1;j<=flag[i];j++)
        {
           now++;
           printf("%d\n",getKth(root,now));
        }
    }
    return 0;
}

3、poj2985

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<iostream>
#define maxn 1111111
#define RED 0
#define BLACK 1
#define nil 0
using namespace std;
int n, m,id,value, root, tot, lefts[maxn], rights[maxn], fa[maxn], key[maxn], color[maxn], size[maxn],p[maxn],rank[maxn];
void init()
{
    root = 0;
    lefts[nil] = rights[nil] = nil;
    fa[nil] = nil; //father of the node
    color[nil] = BLACK;
    size[nil] = 0;
}
void update(int x)
{
    if (x == nil) return;
    size[x] = size[lefts[x]] + size[rights[x]] + 1;
}
void LR(int x)
{
    int y = rights[x];
    rights[x] = lefts[y];
    if (lefts[y] != nil) fa[lefts[y]] = x;
    fa[y] = fa[x];
    if (fa[x] == nil) root = y; //no one node points to y
    else if (x == lefts[fa[x]]) lefts[fa[x]] = y;
    else rights[fa[x]] = y;
    fa[x] = y;
    lefts[y] = x;
    update(x);
    update(y);
}
void RR(int x)
{
    int y = lefts[x];
    lefts[x] = rights[y];
    if (rights[y] != nil) fa[rights[y]] = x;
    fa[y] = fa[x];
    if (fa[x] == nil) root = y; //no one node points to y
    else if (x == lefts[fa[x]]) lefts[fa[x]] = y;
    else rights[fa[x]] = y;
    fa[x] = y;
    rights[y] = x;
    update(x);
    update(y);
}
void insertfixup(int z)
{
    while (color[fa[z]] == RED) // fa[z] cannot be the root since color[root]=BLACK always;
    {
        if (fa[z] == lefts[fa[fa[z]]])
        {
            int w = rights[fa[fa[z]]];
            if (color[w] == RED)
            {
                color[fa[z]] = color[w] = BLACK;
                color[fa[fa[z]]] = RED;
                z = fa[fa[z]]; //color[z]=RED; only this case changes the value of z
            }
            else //color[w]==BLACK;
            {
                if (z == rights[fa[z]]) { z = fa[z]; LR(z); } //leftsrotate(z)   so that z==lefts[fa[z]] 
                color[fa[z]] = BLACK;
                color[fa[fa[z]]] = RED;
                RR(fa[fa[z]]);    //once it is implementated it will break out of the while loop 
                //so there are at most two rotatation LR & RR    
            }
        }
        else //fa[z]==rights[fa[fa[z]]]
        {
            int w = lefts[fa[fa[z]]];
            if (color[w] == RED)
            {
                color[fa[z]] = color[w] = BLACK;
                color[fa[fa[z]]] = RED;
                z = fa[fa[z]]; //color[z]=RED;
            }
            else //color[w]==BLACK
            {
                if (z == lefts[fa[z]]) { z = fa[z]; RR(z); }
                color[fa[z]] = BLACK;
                color[fa[fa[z]]] = RED;
                LR(fa[fa[z]]);
            }
        }
    }
    color[root] = BLACK; //maintain ROOT BLACK
}
void insert(int v)
{
    int y = nil;
    int x = root;
    while (x != nil)
    {
        size[x]++;
        y = x;
        if (v < key[x]) x = lefts[x]; else x = rights[x];
    }
    fa[++tot] = y; lefts[tot] = rights[tot] = nil;;
    key[tot] = v; size[tot] = 1;
    if (y == nil) root = tot;
    else if (v < key[y]) lefts[y] = tot; else rights[y] = tot;
    color[tot] = RED; //red 
    insertfixup(tot);
}
int findmin(int x)
{
    while (lefts[x] != nil) x = lefts[x];
    return x;
}
int succ(int x)
{
    if (rights[x] != nil) return findmin(rights[x]);
    int y = fa[x];
    while (y != nil && x == rights[y])
    {
        x = y;
        y = fa[y];
    }
    return y;
}
void deletesfixup(int z)
{
    while (z != root && color[z] == BLACK) //REDBLACK || BLACKBLACK EXIT
    {
        if (z == lefts[fa[z]])
        {
            int w = rights[fa[z]];
            if (color[w] == RED)
            {
                color[fa[z]] = RED;
                color[w] = BLACK;
                LR(fa[z]); //turns into case 2
                w = rights[fa[z]];
            }            
            if (color[lefts[w]] == BLACK && color[rights[w]] == BLACK)
            {                
                color[w] = RED;
                z = fa[z];
            }
            else
            {
                if (color[rights[w]] == BLACK) //RED BLACK  
                {
                    color[lefts[w]] = BLACK;
                    color[w] = RED; 
                    RR(w); //turns into case 4
                    w = rights[fa[z]]; 
                }
                //RIGHT RED
                color[w] = color[fa[z]];
                color[fa[z]] = BLACK;
                color[rights[w]] = BLACK;
                LR(fa[z]);
                z = root;
            }
        }
        else //z==rights[fa[z]]
        {
            int w = lefts[fa[z]];
            if (color[w] == RED)
            {
                color[fa[z]] = RED;
                color[w] = BLACK;
                RR(fa[z]); //turns into case 2
                w = lefts[fa[z]];
            }
            if (color[lefts[w]] == BLACK && color[rights[w]] == BLACK)
            {
                color[z] = BLACK;
                color[w] = RED;
                z = fa[z];
            }
            else
            {
                if (color[lefts[w]] == BLACK) //RED BLACK  
                {
                    color[rights[w]] = BLACK;
                     color[w] = RED;
                    LR(w); //turns into case 4
                    w = lefts[fa[z]];
                }
                //LEFT RED
                color[w] = color[fa[z]];
                color[fa[z]] = BLACK;
                color[lefts[w]] = BLACK;
                RR(fa[z]);
                z = root;
            }
        }
    }
    color[z] = BLACK;
}
void deletes(int z)
{
    int y;
    if (lefts[z] == nil || rights[z] == nil) y = z;
    else y = succ(z);
    int x;
    if (lefts[y] != nil) x = lefts[y]; else x = rights[y];
    fa[x] = fa[y];
    if (fa[y] == nil) root = x;
        else if (y == lefts[fa[y]]) lefts[fa[y]] = x; 
                else rights[fa[y]] = x;
    if (y != z) key[z] = key[y];
    int p = fa[x];
    while (p != nil) { size[p]--; p = fa[p]; }
    if (color[y] == BLACK) deletesfixup(x);
}
int getKth(int x, int now)
{
    if (size[rights[x]] >= now) return getKth(rights[x], now);
    if (size[rights[x]] + 1 == now) return key[x];
    return getKth(lefts[x], now - size[rights[x]] - 1);
}
int getnode(int v)
{
    int x=root;
    while (key[x]!=v)
    {
       if (v<key[x]) x=lefts[x]; else x=rights[x];
    }
    return x;
}
int getp(int x)
{
    if (p[x]!=x) p[x]=getp(p[x]);
    return p[x];
}
int main()
{
    init();
    scanf("%d %d", &n,&m);
    for (int i = 1; i <=n; i++)
    {
        insert(1);
        p[i]=i;
        rank[i]=1;
    }
    for (int i = 0; i < m; i++)
    {
        int t,x,y;
        scanf("%d",&t);
        if (t==0)
        {        
           scanf("%d %d",&x,&y);      
           int t1=getp(x);
           int t2=getp(y);
           if (t1!=t2)
           {
               p[t2]=t1;
               deletes(getnode(rank[t1]));
               deletes(getnode(rank[t2]));
               rank[t1]+=rank[t2];
               insert(rank[t1]);              
           }
        }
        else
        {
            int k;
            scanf("%d",&k);
            printf("%d\n",getKth(root,k));
        } 
    }
    return 0;
}

4、poj3481

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<iostream>
#define maxn 1111111
#define RED 0
#define BLACK 1
#define nil 0
using namespace std;
int n, m,id,value, root, tot, lefts[maxn], rights[maxn], fa[maxn], key[maxn], color[maxn], size[maxn],p[maxn],rank[maxn],a[maxn];
void init()
{
    root = 0;
    lefts[nil] = rights[nil] = nil;
    fa[nil] = nil; //father of the node
    color[nil] = BLACK;
    size[nil] = 0;
}
void update(int x)
{
    if (x == nil) return;
    size[x] = size[lefts[x]] + size[rights[x]] + 1;
}
void LR(int x)
{
    int y = rights[x];
    rights[x] = lefts[y];
    if (lefts[y] != nil) fa[lefts[y]] = x;
    fa[y] = fa[x];
    if (fa[x] == nil) root = y; //no one node points to y
    else if (x == lefts[fa[x]]) lefts[fa[x]] = y;
    else rights[fa[x]] = y;
    fa[x] = y;
    lefts[y] = x;
    update(x);
    update(y);
}
void RR(int x)
{
    int y = lefts[x];
    lefts[x] = rights[y];
    if (rights[y] != nil) fa[rights[y]] = x;
    fa[y] = fa[x];
    if (fa[x] == nil) root = y; //no one node points to y
    else if (x == lefts[fa[x]]) lefts[fa[x]] = y;
    else rights[fa[x]] = y;
    fa[x] = y;
    rights[y] = x;
    update(x);
    update(y);
}
void insertfixup(int z)
{
    while (color[fa[z]] == RED) // fa[z] cannot be the root since color[root]=BLACK always;
    {
        if (fa[z] == lefts[fa[fa[z]]])
        {
            int w = rights[fa[fa[z]]];
            if (color[w] == RED)
            {
                color[fa[z]] = color[w] = BLACK;
                color[fa[fa[z]]] = RED;
                z = fa[fa[z]]; //color[z]=RED; only this case changes the value of z
            }
            else //color[w]==BLACK;
            {
                if (z == rights[fa[z]]) { z = fa[z]; LR(z); } //leftsrotate(z)   so that z==lefts[fa[z]] 
                color[fa[z]] = BLACK;
                color[fa[fa[z]]] = RED;
                RR(fa[fa[z]]);    //once it is implementated it will break out of the while loop 
                //so there are at most two rotatation LR & RR    
            }
        }
        else //fa[z]==rights[fa[fa[z]]]
        {
            int w = lefts[fa[fa[z]]];
            if (color[w] == RED)
            {
                color[fa[z]] = color[w] = BLACK;
                color[fa[fa[z]]] = RED;
                z = fa[fa[z]]; //color[z]=RED;
            }
            else //color[w]==BLACK
            {
                if (z == lefts[fa[z]]) { z = fa[z]; RR(z); }
                color[fa[z]] = BLACK;
                color[fa[fa[z]]] = RED;
                LR(fa[fa[z]]);
            }
        }
    }
    color[root] = BLACK; //maintain ROOT BLACK
}
void insert(int add,int v)
{
    int y = nil;
    int x = root;
    while (x != nil)
    {
        size[x]++;
        y = x;
        if (v < key[x]) x = lefts[x]; else x = rights[x];
    }
    fa[++tot] = y; lefts[tot] = rights[tot] = nil;;
    key[tot] = v; size[tot] = 1;
    a[tot]=add;
    if (y == nil) root = tot;
    else if (v < key[y]) lefts[y] = tot; else rights[y] = tot;
    color[tot] = RED; //red 
    insertfixup(tot);
}
int findmin(int x)
{
    while (lefts[x] != nil) x = lefts[x];
    return x;
}
int succ(int x)
{
    if (rights[x] != nil) return findmin(rights[x]);
    int y = fa[x];
    while (y != nil && x == rights[y])
    {
        x = y;
        y = fa[y];
    }
    return y;
}
void deletesfixup(int z)
{
    while (z != root && color[z] == BLACK) //REDBLACK || BLACKBLACK EXIT
    {
        if (z == lefts[fa[z]])
        {
            int w = rights[fa[z]];
            if (color[w] == RED)
            {
                color[fa[z]] = RED;
                color[w] = BLACK;
                LR(fa[z]); //turns into case 2
                w = rights[fa[z]];
            }            
            if (color[lefts[w]] == BLACK && color[rights[w]] == BLACK)
            {                
                color[w] = RED;
                z = fa[z];
            }
            else
            {
                if (color[rights[w]] == BLACK) //RED BLACK  
                {
                    color[lefts[w]] = BLACK;
                    color[w] = RED; 
                    RR(w); //turns into case 4
                    w = rights[fa[z]]; 
                }
                //RIGHT RED
                color[w] = color[fa[z]];
                color[fa[z]] = BLACK;
                color[rights[w]] = BLACK;
                LR(fa[z]);
                z = root;
            }
        }
        else //z==rights[fa[z]]
        {
            int w = lefts[fa[z]];
            if (color[w] == RED)
            {
                color[fa[z]] = RED;
                color[w] = BLACK;
                RR(fa[z]); //turns into case 2
                w = lefts[fa[z]];
            }
            if (color[lefts[w]] == BLACK && color[rights[w]] == BLACK)
            {
                color[z] = BLACK;
                color[w] = RED;
                z = fa[z];
            }
            else
            {
                if (color[lefts[w]] == BLACK) //RED BLACK  
                {
                    color[rights[w]] = BLACK;
                     color[w] = RED;
                    LR(w); //turns into case 4
                    w = lefts[fa[z]];
                }
                //LEFT RED
                color[w] = color[fa[z]];
                color[fa[z]] = BLACK;
                color[lefts[w]] = BLACK;
                RR(fa[z]);
                z = root;
            }
        }
    }
    color[z] = BLACK;
}
void deletes(int z)
{
    int y;
    if (lefts[z] == nil || rights[z] == nil) y = z;
    else y = succ(z);
    int x;
    if (lefts[y] != nil) x = lefts[y]; else x = rights[y];
    fa[x] = fa[y];
    if (fa[y] == nil) root = x;
        else if (y == lefts[fa[y]]) lefts[fa[y]] = x; 
                else rights[fa[y]] = x;
    if (y != z)
    {
        key[z] = key[y];
        a[z] = a[y];
    }
    int p = fa[x];
    while (p != nil) { size[p]--; p = fa[p]; }
    if (color[y] == BLACK) deletesfixup(x);
}
int getmax(int x)
{
    if (rights[x]==nil) return x;
    return getmax(rights[x]);
}
int getmin(int x)
{
    if (lefts[x]==nil) return x;
    return getmin(lefts[x]);
}
int main()
{
    init();
    int t,k,v;
    scanf("%d", &t);
    while (t)
    {
        if (t==1)
        {
           scanf("%d %d",&k,&v);
           insert(k,v);
        }
        else if (t==2)
             {
                int ans=getmax(root);
                printf("%d\n",a[ans]);
                deletes(ans);
             }
             else
             {
                 int ans=getmin(root);
                 printf("%d\n",a[ans]);
                 deletes(ans);
             }
        scanf("%d",&t);
    }
    return 0;
}

 

转载于:https://www.cnblogs.com/strawberryfgalois/p/4127529.html

aichan3852
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
红黑树的插入详细图解，直接拿下红黑树
08-17
红黑树是一种自平衡二叉查找树，它的主要特点是在保持二叉查找树特性的同时，通过特定的颜色规则来确保树的平衡，以达到快速查找、插入和删除的目的。红黑树的每个节点都有一个颜色属性，可以是红色或黑色。在插入新...
红黑树java操作代码 红黑树是java里面遍历性能最好数据结构
10-17
红黑树（Red-Black Tree）是一种自平衡二叉查找树，它在计算机科学中扮演着重要的角色，尤其是在实现高效的数据结构和算法时。在Java中，虽然标准库并未直接提供红黑树的类，但我们可以自定义实现，如提供的`Red...
对红黑树的认识总结
热门推荐
张彦峰的博客
05-12 170万+
当在红黑树中执行插入操作时，需要考虑两个主要方面：保持二叉搜索树性质和保持红黑性质。以下是插入操作的详细步骤，包括可能的旋转操作和颜色调整。插入操作的基本步骤：首先，将新节点插入到红黑树中，就像在普通的二叉搜索树中一样。新节点会被标记为红色，因为它可能会破坏红黑性质的第一个性质（根节点必须是黑色）。插入新节点后，可能会破坏红黑性质。需要通过一系列的操作来调整以确保所有的红黑性质得到满足。在进行旋转操作之前，需要进行颜色调整以满足红黑性质。
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
小七的博客
01-18 20万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
C++红黑树
~
03-26 6676
C++红黑树零、前言一、红黑树的概念及性质二、红黑树结点的定义三、红黑树的插入操作1、变色处理2、单旋+变色3、双旋+变色4、插入实现四、红黑树的验证五、红黑树的删除六、红黑树与**AVL**树的比较 零、前言 本章继AVL树后继续讲解学习C++中另一个二叉搜索树–红黑树 一、红黑树的概念及性质 概念： 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长
红黑树详解
lucyLee的博客
09-12 10万+
1. 概述 1.1 红黑树的引入 有了二叉搜索树，为什么还需要平衡二叉树？ 在学习二叉搜索树、平衡二叉树时，我们不止一次提到，二叉搜索树容易退化成一条链 这时，查找的时间复杂度从O(log2N)O(log_2N)O(log2​N)也将退化成O(N)O(N)O(N) 引入对左右子树高度差有限制的平衡二叉树，保证查找操作的最坏时间复杂度也为O(log2N)O(log_2N)O(log2​N) 有了平衡二叉树，为什么还需要红黑树？ AVL的左右子树高度差不能超过1，每次进行插入/删除操作时，几乎都需要通过旋
图解红黑树
Dablelv 的博客专栏。
08-10 1726
1.红黑树简介 红黑树（Red Black Tree）是一种含有红黑结点并能自平衡二叉查找树，典型的用途是实现 map。 它必须满足下面规则： 规则1：每个结点要么是黑色，要么是红色。 规则2：根结点是黑色。 规则3：每个叶子结点（NIL）是黑色。 规则4：每个红色结点的两个子结点都是黑色。 规则5：任意一结点到每个叶子结点的路径都包含相同数量的黑结点。 记住上面的规则也不难，我们会发现黑色结点非常特殊，规则1即“非红即黑”，规则2和3即“首尾全黑”，规则4即“红子双黑”，规则5即“路径等黑”。 这些规则
红黑树介绍
mz474920631的博客
05-28 4万+
红黑树一、红黑树的概念红黑树的性质红黑树节点的定义红黑树结构二、使用步骤1.引入库2.读入数据总结 一、红黑树的概念 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 红黑树的性质 每个结点不是红色就是黑色 根节点是黑色的 如果一个节点是红色的，则它的两个孩子结点是黑色的 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数
红黑树简介
Charge8的博客
12-28 834
红黑树简介
面试常问：什么是红黑树？
Mr.TS的博客
10-22 7万+
什么是红黑树？   ———————————— 二叉查找树（BST）具备什么特性呢？ 1.左子树上所有结点的值均小于或等于它的根结点的值。 2.右子树上所有结点的值均大于或等于它的根结点的值。 3.左、右子树也分别为二叉排序树。 下图中这棵树，就是一颗典型的二叉查找树： 1.查看根节点9： 2.由于10 &gt; 9，...
红黑树-Java实现
weixin_37607613的博客
04-05 9099
一、定义 红黑树是特殊的平衡二叉树，具有以下特性： 1、根节点的颜色是黑色 2、节点颜色要么是黑色、要么是红色 3、如果一个节点的颜色是红色，则它的子节点必须是黑色，即不能有2个连续的红色节点 4、每个叶子节点都是黑色(这里的叶子节点是为空的叶子节点) 5、从一个节点到该节点的叶子节点的所有路径上都包含相同数量的黑色节点 通过上面的定义，可以看到红黑树本质上还是一颗二叉查找树，所以，对红黑树的插入删除操作都可以分为两阶段来完成，首先，将红黑树看成一颗普通的二叉查找树完成插入删除操....
红黑树与区间树算法实现
04-08
红黑树和区间树是两种在计算机科学中广泛使用的数据结构，主要应用于高效的数据管理和查询。在本实验中，我们探讨了如何用C++来实现这两种数据结构，并提供了相关的可视化功能。 红黑树是一种自平衡二叉查找树，由...
红黑树：红黑树的Matlab实现-matlab开发
05-30
红黑树是一种自平衡二叉查找树，由Rudolf Bayer于1972年提出。它的设计目标是在保持二叉查找树基本性质的同时，通过引入颜色（红色或黑色）来确保任何节点到其每个叶子节点的所有路径都具有相同的黑色节点数，从而...
控制台打印红黑树.rar
05-17
红黑树（Red-Black Tree）是一种自平衡二叉查找树，由计算机科学家鲁道夫·贝尔在1978年提出。它在保持二叉查找树特性的同时，通过引入颜色属性来确保树的平衡，从而优化了查找、插入和删除操作的时间复杂度。红黑树...
单向链表
最新发布
qq_69639971的博客
09-04 399
【代码】单向链表。
LeetCode LCR088.使用最小花费爬楼梯
m0_63816268的博客
09-03 833
动态规划
位运算专题——常见位运算&位图的使用&力扣实战应用
2401_83595513的博客
09-02 1192
位运算专题
【每日一题】LeetCode 643.最大平均数的连续子数组
Hanbuhuic的博客
08-30 323
本文介绍了一种算法问题——寻找平均数最大的长度为 k 的连续子数组。问题背景是给定一个整数数组 nums 和一个整数 k，目标是找到并输出具有最大平均数的子数组。文章首先提供了问题的输入示例和提示，然后详细分析了解题思路，即利用滑动窗口技术来高效地解决问题。接着，文章提供了Java语言的代码实现，并附有详细的注释，以帮助读者理解算法的逻辑。
左倾红黑树算法深度解析
"这篇资源是关于红黑树算法的详尽解释，由Robert Sedgewick，来自普林斯顿大学的专家撰写。它最初在2008年的Dagstuhl数据结构研讨会上发表，随后在Maresias的算法分析会议上进行了更新。文章包括了对红黑树的简化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值