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 = 100000;  
int key[N], l[N], r[N], p[N];  
int u, node;  
  
int Search(int x, int k)//查询  
{  
    if(x == 0 || 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 != 0 && k != key[x])  
        if(k < key[x])  
            x = l[x];  
        else  
            x = r[x];  
    return x;  
}  
  
int Minimum(int x)  
{  
    while(l[x] != 0)  
        x = l[x];  
    return x;  
}  
  
int Maximum(int x)  
{  
    while(r[x] != 0)  
        x = r[x];  
    return x;  
}  
  
int Successor(int x)  
{  
    if(r[x] != 0)  
        return Minimum(r[x]);  
    int y = p[x];  
    while(y != 0 && x == r[y])  
    {  
        x = y;  
        y = p[y];  
    }  
    return y;  
}  
  
int Predecessor(int x)  
{  
    if(l[x] != 0)  
        return Maximum(l[x]);  
    int y = p[x];  
    while(y != 0 && x == l[y])  
    {  
        x = y;  
        y = p[y];  
    }  
    return y;  
}  
  
void Insert(int &T, int v)//插入结点  
{  
    if(T == 0)  
        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 = 0;  
    int x = T;  
    int z = ++node;  
    key[z] = v;  
    while(x != 0)  
    {  
        y = x;  
        if(key[z] < key[x])  
            x = l[x];  
        else  
            x = r[x];  
    }  
    p[z] = y;  
    if(y == 0)  
        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] == 0)  
        T = v;  
    else if(u == l[p[u]])  
        l[p[u]] = v;  
    else  
        r[p[u]] = v;  
    if(v != 0)  
        p[v] = p[u];  
}  
  
void Delete(int T, int z)//删除结点  
{  
    if(l[z] == 0)  
        Transplant(T, z, r[z]);  
    else if(r[z] == 0)  
        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=0; i<n; i++)  
    {  
        int k;  
        scanf("%d",&k);  
        Insert(u, k);  
    }  
    Delete(u, Search(u, 1));  
    printf("%d
",Search(u,2));  
    printf("%d
",Maximum(u));  
    return 0;  
}