nyoj _202: 紅黑樹
紅黑樹
時間限制：3000 ms | 內存限制：65535 KB
難度：3
描述
什麼是紅黑樹呢？顧名思義，跟棗樹類似，紅黑樹是一種葉子是黑色果子是紅色的樹。。。
當然，這個是我說的。。。
《算法導論》上可不是這麼說的：
如果一個二叉查找樹滿足下面的紅黑性質，那麼則爲一個紅黑樹。
1）每個節點或是紅的，或者是黑的。
2）每個葉子節點(NIL)是黑色的
3）如果一個節點是紅色的，那麼他的兩個兒子都是黑的。
4）根節點是黑色的。
5）對於每個節點，從該節點到子孫節點的所有路徑上包含相同數目的黑色節點。
我們在整個過程中會用到這些性質，當然，爲了公平起見，其實即使你不知道這些性質，這個題目也是可以完成的（爲什麼不早說。。。。）。在紅黑樹的各種操作中，其核心操作被稱爲旋轉，那麼什麼是旋轉呢，我們來看一個例子：
假設我們這裏截取紅黑樹的一部分，放在左邊，通過操作如果可以把他轉化爲右邊的形式，那麼我們就稱將根爲x的子樹進行了左旋，反之我們稱將根爲Y的樹進行了右旋：
恰好慢板同學把自己紅黑樹弄亂了，然後請你幫忙進行修復，他將向你描述他的紅黑樹（混亂的。。。）。然後告訴他需要用哪種方式旋轉某個節點。在你完成工作之後，直接向大黃提交新的樹的中序遍歷結果就好了。
Hint:
在這裏好心的慢板同學給你簡單的解釋下樣例：
最開始的時候樹的樣子是這樣的：
0
/ \
1 2
然後對於標號爲0的節點進行右旋，結果將變爲：
1
\
0
\
2
然後呢。。。
中序遍歷？這個是什麼東西，哪個人可以告訴我下。。。。
輸入
輸入分兩部分：
第一部分：一個整數T(1<=T<=10),表示測試的組數。
第二部分：第一行是一個數字N，表示紅黑樹的節點個數。0<N<10
然後下面有N行，每行三個數字，每個數字的大小都在-1~N-1之間。第一個數字表示當前節點的標號，後面兩個數字表示這個節點的左孩子和右孩子。如果是-1的話表示是空節點。對於所有的輸入來說標號爲0節點爲根。
然後是一個數字M表示需要旋轉的次數。M<100
接下來M行，每行有兩個數字，分別表示你要旋轉的節點標號和你需要的操作。標號的範圍爲0~n-1,如果標號後面的數字0，那麼表示爲左旋。如果是1，則表示右旋。
輸出
每組測試返回N行數字，表示對樹的中序遍歷。在每組測試數據之後留一行空行。
樣例輸入
1
3
0 1 2
1 -1 -1
2 -1 -1
1
0 1
樣例輸出
1
0
2
按要求左旋和右旋就行
後來才反應過來紅黑樹進行左旋和右旋操作不影響中序遍歷的結果，因爲紅黑樹本身是一種二叉搜索樹
NYOJ好像最近出故障了，代碼還沒交急死了，過幾天再試着交…
//按照要求旋轉的代碼
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 10005;
int root = maxn;
/**
1
3
0 1 2
1 -1 -1
2 -1 -1
1
0 1
*/
struct nodeP{
int l;
int r;
int fa;
}p[maxn];
void init()
{
for(int i=0;i<maxn;++i)
{
p[i].l = -1;
p[i].r = -1;
p[i].fa = -1;
}
p[0].fa = root;
p[root].l = 0;
p[root].r = 0;
}
int rturn(int x) //右旋
{
int root_1 = p[x].fa;
int y = p[x].l;
if(p[p[x].fa].l == x) //x是左兒子
{
p[p[x].fa].l = p[x].l;
if(p[x].fa == maxn)
{
p[p[x].fa].r = p[p[x].fa].l = p[x].l;
}
}else if(p[p[x].fa].r == x) //x是右兒子
{
p[p[x].fa].r = p[x].l;
if(p[x].fa == maxn)
{
p[p[x].fa].r = p[p[x].fa].l = p[x].l;
}
}
p[p[x].l].fa = p[x].fa;
p[x].l = p[y].r;
p[p[y].r].fa = x;
p[x].fa = y;
p[y].r = x;
return 0;
}
int lturn(int x) //左旋
{
int y = p[x].r;
if(p[p[x].fa].l == x) {
p[p[x].fa].l = p[x].r;
if(p[x].fa==maxn)
{
p[p[x].fa].r = p[p[x].fa].l = p[x].r;
}
}else if(p[p[x].fa].r == x){
p[p[x].fa].r = p[x].r;
if(p[x].fa==maxn)
{
p[p[x].fa].r = p[p[x].fa].l = p[x].r;
}
}
p[p[x].r].fa = p[x].fa;
p[x].r = p[y].l;
p[p[y].l].fa = x;
p[x].fa = y;
p[y].l = x;
return 0;
}
void dfs(int node)
{
if(node==-1)
{
return ;
}
dfs(p[node].l);
cout<<node<<endl;
dfs(p[node].r);
}
int main()
{
int T;
cin>>T;
while(T--)
{
int n;
cin>>n;
int a,l,r;
init();
for(int i=0;i<n;++i)
{
cin>>a>>l>>r;
p[a].l = l;
p[a].r = r;
p[l].fa = a;
p[r].fa = a;
}
int t,x,y;
cin>>t;
for(int i=0;i<t;++i)
{
cin>>x>>y; //對節點x進行旋轉
if(y==0) //左旋
{
lturn(x);
}else if(y==1) //右旋
{
rturn(x);
}
}
// int ans = p[root].l;
// cout<<"root 的左右孩子"<<p[root].l<<" "<<p[root].r<<endl;
// for(int i=0;i<10;++i)
// {
// cout<<i<<" "<<p[i].fa<<" "<<p[i].l<<" "<<p[i].r<<endl;
// }
dfs(p[root].l);
}
return 0;
}
//直接中序遍歷
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 10005;
struct nodeP{
int l;
int r;
int fa;
}p[maxn];
void init()
{
for(int i=0;i<maxn;++i)
{
p[i].l = -1;
p[i].r = -1;
p[i].fa = -1;
}
}
void dfs(int node)
{
if(node==-1)
{
return ;
}
dfs(p[node].l);
cout<<node<<endl;
dfs(p[node].r);
}
int main()
{
int T;
cin>>T;
while(T--)
{
int n;
cin>>n;
int a,l,r;
init();
for(int i=0;i<n;++i)
{
cin>>a>>l>>r;
p[a].l = l;
p[a].r = r;
p[l].fa = a;
p[r].fa = a;
}
int t,x,y;
cin>>t;
for(int i=0;i<t;++i)
{
cin>>x>>y;
}
dfs(0);
}
return 0;
}