BST(Binary Search Tree)

原文链接：http://blog.csdn.net/jarily/article/details/8679280

 /******************************************
 数据结构：
 BST(Binary Search Tree),二叉查找树; 

 性质：
 若结点的左子树不空，则左子树上所有结点的值均小于它的根结点的值;
 若结点的右子树不空，则右子树上所有结点的值均大于它的根结点的值;
 该结点的左、右子树也分别为二叉查找树; 

 遍历：
 对于一个已知的二叉查找树,从小到大输出其节点的值;
 只需对其进行二叉树的中序遍历即可;
 即递归地先输出其左子树,再输出其本身,然后输出其右子树;
 遍历的时间复杂度为O(n); 

 查找：
 对于一个已知的二叉查找树x;
 在其中查找特定的值k,函数Search返回指向值为k的节点指针;
 若找不到则返回0,算法时间复杂度为O(h),h为树的高度;
 理想情况下时间复杂度为lgn; 

 最大值和最小值：
 要查找二叉查找树中具有最小值的元素;
 只要从根节点开始,沿着左子树找到最左边的节点就可以了;
 反之沿着右子树查找则可以求最大值; 

 插入：
 从根节点开始插入;
 如果要插入的值小于等于当前节点的值，在当前节点的左子树中插入;
 如果要插入的值大于当前节点的值，在当前节点的右子树中插入;
 如果当前节点为空节点，在此建立新的节点，该节点的值为要插入的值，左右子树为空，插入成功; 

 删除：
 如果该没有子女，直接删除;
 如果该结点只有一个子女，则删除它，将其子女的父亲改为它的父亲;
 如果该结点有两个子女，先用其后继替换该节点，其后继的数据一并加在其后;
 *******************************************/
 #include<iostream>
 #include<cstring>
 #include<cstdlib>
 #include<cstdio>
 #include<climits>
 #include<algorithm>
 using namespace std;  

 const int N = ;
 int key[N], l[N], r[N], p[N];
 int u, node;  

 int Search(int x, int k)//查询
 {
     if(x ==  || k == key[x])
         return x;
     if(k < key[x])
         return Search(l[x], k);
     else
         return Search(r[x], k);
 }  

 int Iterative_Search(int x, int k)//非递归版本的查询
 {
     while(x !=  && k != key[x])
         if(k < key[x])
             x = l[x];
         else
             x = r[x];
     return x;
 }  

 int Minimum(int x)
 {
     while(l[x] != )
         x = l[x];
     return x;
 }  

 int Maximum(int x)
 {
     while(r[x] != )
         x = r[x];
     return x;
 }  

 int Successor(int x)
 {
     if(r[x] != )
         return Minimum(r[x]);
     int y = p[x];
     while(y !=  && x == r[y])
     {
         x = y;
         y = p[y];
     }
     return y;
 }  

 int Predecessor(int x)
 {
     if(l[x] != )
         return Maximum(l[x]);
     int y = p[x];
     while(y !=  && x == l[y])
     {
         x = y;
         y = p[y];
     }
     return y;
 }  

 void Insert(int &T, int v)//插入结点
 {
     if(T == )
         key[T = ++node] = v;
     else if(v <= key[T])
     {
         p[l[T]] = T;
         Insert(l[T], v);
     }
     else
     {
         p[r[T]] = T;
         Insert(r[T], v);
     }
 }  

 void Iterative_Insert(int T, int v)//非递归版本插入结点
 {
     int y = ;
     int x = T;
     int z = ++node;
     key[z] = v;
     while(x != )
     {
         y = x;
         if(key[z] < key[x])
             x = l[x];
         else
             x = r[x];
     }
     p[z] = y;
     if(y == )
         key[T] = z;
     else if(key[z] < key[y])
         l[y] = z;
     else
         r[y] = z;
 }  

 void Transplant(int T, int u, int v)//移植过程;
 //把一棵子树u归并到另一棵子树v中，u的父亲变为v的父亲，u的父亲就有了v作为其孩子。
 {
     if(p[u] == )
         T = v;
     else if(u == l[p[u]])
         l[p[u]] = v;
     else
         r[p[u]] = v;
     if(v != )
         p[v] = p[u];
 }  

 void Delete(int T, int z)//删除结点
 {
     if(l[z] == )
         Transplant(T, z, r[z]);
     else if(r[z] == )
         Transplant(T, z, l[z]);
     else
     {
         int y = Minimum(r[z]);
         if(p[y] != z)
         {
             Transplant(T, y, r[y]);
             r[y] = r[z];
             p[r[y]] = y;
         }
         Transplant(T, z, y);
         l[y] = l[z];
         p[l[y]] = y;
     }
 }  

 int main()
 {
     int n;
     scanf("%d",&n);
     for(int i=; i<n; i++)
     {
         int k;
         scanf("%d",&k);
         Insert(u, k);
     }
     Delete(u, Search(u, ));
     printf("%d\n",Search(u,));
     printf("%d\n",Maximum(u));
     return ;
 }