数据结构--二叉序树

<pre name="code" class="cpp">// Binary Sort Tree.cpp : Defines the entry point for the console application.
/*-----CODE FOR FUN---------------
-------CREATED BY Dream_Whui------
-------2015-3-5-------------------------*/  
//二叉排序树
#include "stdafx.h"
#include <iostream>
using namespace std;

#define        TRUE                     1  
#define        FALSE                    0  
#define        OK                         1  
#define        ERROR                   0  
#define        OVERFLOW           -2  
#define        INFEASIBLE           -1

#define        EQ(a,b)        (a == b)
#define        LT(a,b)        (a < b)
#define        LQ(a,b)        (a > b)

typedef        char            KeyType;

struct ElemType
{
    KeyType    name;
    int            key;
};

typedef struct BiTNode                    //定义二叉树的结构  
{  
    ElemType    data;                        //数据域  
    struct BiTNode    *lchild,*rchild;//左子树，右子树  
}BiTNode,*BiTree;

int InitBiTree(BiTree &T)            
{
    T = NULL;
    return OK;
}

void DestroyBiTree(BiTree &T)  
{
    if(T)
    {
        if(T->lchild)
            DestroyBiTree(T->lchild);
        if(T->rchild)
            DestroyBiTree(T->rchild);
        free(T);
        T=NULL;
    }
}

int BiTreeEmpty(BiTree T)
{
    if(T)
        return FALSE;
    else
        return TRUE;
}

BiTree SearchBST(BiTree T, int key)//在根指针T所指二叉排序树中递归地查找某关键字等于key的数据元素
{                                                    //若查找成功，则返回指向该数据元素结点的指针，否则返回空指针
    if( (!T) || EQ(T->data.key , key) )//查找结束
        return T;
    else
    {
        if( LT(T->data.key , key) )            //在右子树中继续查找
            SearchBST(T->rchild , key);    
        else
            SearchBST(T->lchild , key);    //在左子树中继续查找
    }
}

int SearchBST(BiTree T, int key, BiTree f, BiTree &p)//在根指针T所指二叉序树中递归地查找其关键字等于key的数据元素
{                                                                            //若查找成功，则指针p指向该数据元素结点，并返回TRUE,否则返回p指向查找路径上访问的
    if(!T)                //查找不成功                                    //最后一个结点并返回FALSE,指针f指向T的双亲，初始值为NULL
    {
        p = f;
        return FALSE;
    }
    else if(EQ(key , T->data.key))//查找成功
    {
        p = T;
        return TRUE;
    }
    else if(LT(key , T->data.key))//在左子树中继续查找
    {
        return SearchBST(T->lchild, key, T, p);
    }
    else
        return SearchBST(T->rchild, key, T, p);//在右子树中继续查找

}

int InsertBST(BiTree &T, ElemType e)//当二叉序树T中不存在关键字等于e.key的数据元素时，插入e返回TRUE
{                                                        //否则返回FALSE
    BiTree p;
    if(!SearchBST(T,e.key,NULL,p))        //查找不成功
    {
        BiTree s = (BiTree)malloc(sizeof(BiTNode));
        s->data = e;
        s->lchild = s->rchild = NULL;
        if(!p)                                            //被插结点*s为新的根结点
            T = s;
        else if(LT(e.key, p->data.key))    //被插结点*s为左孩子
            p->lchild = s;
        else
            p->rchild = s;                        //被插结点*s为右孩子
        return TRUE;
    }
    else
        return FALSE;                            //树中已有相同结点，不再插入
}

int Delete(BiTree &p)        //从二叉序树中删除几点p，并重接它的左或右子树
{
    BiTree q, s;
    if(!p->lchild)                    //左子树空，只需重接它的右子树
    {
        q = p;
        p = p->rchild;
        free(q);
    }
    else if(!p->rchild)        //右子树空，只需重接它的左子树
    {
        q = p;
        p = p->lchild;
        free(q);
    }
    else                            //左右子树均不空
    {
        q = p;
        s = p->lchild;
        while(s->rchild)
        {
            q = s;
            s = s->rchild;
        }                        //s指向被删结点的“前驱”
        p->data = s->data;
        if(q != p)
            q->rchild = s->lchild;
        else
            q->lchild = s->lchild;
        free(s);
    }
    return TRUE;
}

int DeleteBSF(BiTree &T, int key)
{
    if(!T)
        return FALSE;
    else
    {
        if(EQ(key, T->data.key))
            return Delete(T);
        else if(LT(key, T->data.key))
            DeleteBSF(T->lchild,key);
        else
            DeleteBSF(T->rchild,key);
    }
}

void Visit(ElemType e)
{
    cout<<e.key<<" ";
}

void InOrderTraverse(BiTree T, void(*Visit)(ElemType))  //中序遍历
{
    if(T)
    {
        InOrderTraverse(T->lchild,Visit);
        Visit(T->data);
        InOrderTraverse(T->rchild,Visit);
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    BiTree T;
    InitBiTree(T);
    ElemType R[10]={{'A',45},{'B',12},{'C',53},{'D',3},{'E',37},{'F',100},{'H',24},{'I',61},{'J',90},{'K',78}};
    for(int i=0; i<10; i++)
        InsertBST(T,R[i]);
    InOrderTraverse(T,Visit);
    BiTree temp = SearchBST(T,12);
    if(temp)
        cout<<temp->data.name<<endl;
    DeleteBSF(T,12);
    InOrderTraverse(T,Visit);
    return 0;
}