二叉树的定义及基本操作

二叉树的定义及基本操作

二叉树是另一种树形结构，它的特点是每个结点至多只有两棵子树，并且，二叉树的子树有左右之分，其次序不能任意颠倒。

1、InitBiTree（&T）；
操作结果：构造空二叉树

void InitBiTree(BiTree &T)
 { 
   T=NULL;
 }

2、DestroyBiTree（&T）
初始条件：二叉树T存在
操作结果：销毁二叉树T

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

3、CreateBiTree（&T，definition）；
初始条件：definition给出二叉树T的定义
操作结果：按definition构造二叉树T

void createBiTree(BiTree &T)  
{  
    char data;  
    data = getchar();  
    if(data == '#')  
    {  
        T = NULL;  
    }  
    else  
    {  
        T = new BiTreeNode;  
        T->data = data;  
        createBiTree(T->lchild);  
        createBiTree(T->rchild);  
    }  
}  

4、ClearBiTree(&T)
初始条件：二叉树T存在
操作结果：将二叉树T清为空树

void ClearTree(Tree *T)  
{  
    if (!*T)  
    {  
        return;  
    }  

    ClearTree(&(*T)->left);  
    ClearTree(&(*T)->right);  
    free(*T);  
    *T = NULL;  
}  

5、BiTreeEmpty(T);
初始条件：二叉树T存在
操作结果：若T为空二叉树，则返回TRUE，否则FALSE。

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

6、BiTreeDepth（T）
初始条件：二叉树T存在
操作结果：返回T的深度

int BiTreeDepth(BiTNode *T)  
{  
    int Depth = 0;  
    if (T != NULL){  
        int leftDepth = TreeDepth(T->lChild);  
        int rightDepth = TreeDepth(T->rChild);  
        Depth = leftDepth >= righDepth?leftDepth+1:rightDepth+1;  
    }  

    return Depth;  
}  

7、Root（T）
初始条件：二叉树T存在
操作结果：返回T的根

TElemType Root(BiTree T)
{
    return T->data;
}

8、Value（T，e）
初始条件：二叉树T存在，e是T中某个结点
操作结果：返回e的值

TElemType Value(T,  node) 
{
    return node->data;
}

9、Assign（T，&e，value）
初始条件：二叉树T存在，e是T中某个结点
操作结果：结点e赋值value

Status Assign(Position *node,TElemType value) { 
    (*node)->data = value;
    return OK;
}

10、Parent（T，e）
初始条件：二叉树T存在，e是T中某个结点
操作结果：若e是T的非根结点，则返回它的双亲，否则返回“空”

BiTree Parent(BiTree T,BiTNode* e)
{
    if(T){
        if(T->data==e->data)
            return NULL;
    }
    if(T->lchild!=NULL && T->lchild->data==e->data||T->rchild!=NULL && T->rchild->data==e->data) 
        return T;
    else
    {
        BiTNode* tempP=NULL;
            if(tempP=Parent(T->lchild,e))
                return tempP;
            if(tempP=Parent(T->rchild,e))
                return tempP;
    }
    return NULL;
}

11、LeftChild(T,e);
初始条件：二叉树T存在，e是T中某个结点
操作结果：返回e的左孩子。若e无左孩子，则返回“空”

TElemType LeftChild(BiTree T,TElemType elem) {
    Position p;
    p = NodePoint(T,elem);
    if(p->lchild)
        return p->lchild->data;
    return NULL;
}

12、RightChild（T，e）
初始条件：二叉树T存在，e是T中某个节点
操作结果：返回e的右孩子。若e无右孩子，则返回“空”

TElemType RightChild(BiTree T,TElemType elem) {
    Position p;

    p = NodePoint(T,elem);

    if(p->rchild)
        return p->rchild->data;

    return NULL;
}

13、LeftSibling（T，e）
初始条件：二叉树T存在，e是T中某个结点
操作结果：返回e的左兄弟。若e是T的左孩子或无左兄弟，则返回“空”。

TElemType LeftSibling(BiTree T,TElemType e)  
{ 
    TElemType a;  
    BiTree p;  
    if(T)
    {  
        a=Parent(T,e); 
        p=Point(T,a); 
        if(p->lchild&&p->rchild&&p->rchild->data==e) 
            return p->lchild->data; 
    }  
    return NULL; 
}  

14、RightSibling（T，e）
初始条件：二叉树T存在，e是T中某个结点
操作结果：返回e的右兄弟。若e是T的右孩子或无右兄弟，则返回“空”。

TElemType LeftSibling(BiTree T,TElemType e)  
{ 
    TElemType a;  
    BiTree p;  
    if(T)
    {  
        a=Parent(T,e); 
        p=Point(T,a); 
        if(p->rchild&&p->lchild&&p->lchild->data==e) 
            return p->rchild->data; 
    }  
    return NULL; 
}  

15、InsertChild（T，p，LR，c）
初始条件：二叉树T存在，p指向T中某个结点，LR为0或1，非空二叉树c与T不相交且右子树为空。
操作结果： 根据LR为0或1，插入c为T中p所指结点的左或右子树。p所指结点的原有左子树或右子树则成为c的右子树

Status InsertChild(Position p,int LR,BiTree c) {
    if(p) {
        if(LR == 0) {
            c->rchild = p->lchild;
            p->lchild = c;
        }
        else if(LR == 1) {
            c->rchild = p->rchild;
            p->rchild = c;
        }

        return OK;
    }
    else
        return ERROR;
}

16、DeleteChild（T， p，LR）
初始条件：二叉树T存在，p指向T中某个结点，LR为0或1.
操作结果：根据LR为0或1，删除T中p所指结点的左或右子树。

Status DeleteChild(Position p,int LR) {
    if(LR == 0) {
        if(p->lchild) {
            DestoryBiTree(&p->lchild);
            return OK;
        }
    }
    else if(LR == 1) {
        if(p->rchild) {
            DestoryBiTree(&p->rchild);
            return OK;
        }
    }


    return ERROR;

}

17、PreOrderTraverse(T Visit( ) );
初始条件：二叉树T存在。Visit是对结点操作的应用函数。
操作结果：先序遍历T，对每个结点调用函数visit一次且仅一次。一旦visit（）失败，则操作失败

Status PostOrderTraverse(BiTree T,Status (*visit)(TElemType elem)) {
    if(T) {
        if(PostOrderTraverse(T->lchild,visit))
            if(PostOrderTraverse(T->rchild,visit))
                if(visit(T->data))
                    return OK;
        return ERROR;
    }

    return OK;
}

18、InOrderTraverse(T, Visit( ) );
初始条件：二叉树T存在，Visit是对结点操作的应用函数。
操作结果：中序遍历T，对每个结点调用函数visit一次且仅一次。一旦visit（）失败，则操作失败

Status InOrderTraverse(BiTree T,Status (*visit)(TElemType elem)) {
    if(T) {
        if(InOrderTraverse(T->lchild,visit))
            if(visit(T->data))
                if(InOrderTraverse(T->rchild,visit))
                    return OK;
        return ERROR;
    }

    return OK;
}

19、PostOrderTraverse（T，Visit（））；
初始条件：二叉树T存在，Visit是对结点操作的应用函数。
操作结果：后序遍历T，对每个结点调用函数visit一次且仅一次。一旦visit（）失败，则操作失败

Status PostOrderTraverse(BiTree T,Status (*visit)(TElemType elem)) {
    if(T) {
        if(PostOrderTraverse(T->lchild,visit))
            if(PostOrderTraverse(T->rchild,visit))
                if(visit(T->data))
                    return OK;
        return ERROR;
    }

    return OK;
}

20、LevelOrderTraverse(T, Visit( ) );
初始条件：二叉树T存在，Visit是对结点操作的应用函数。
操作结果：层序遍历T，对每个结点调用函数visit一次且仅一次。一旦visit（）失败，则操作失败

Status LevelOrderTraverse(BiTree T,Status (*visit) (TElemType elem)) {
    if(T == NULL)
        return ERROR;

    LinkQueue TreeQueue;
    ElemType p;

    InitQueue(&TreeQueue);
    p = T;

    EnQueue(&TreeQueue,p);

    while(!QueueEmpty(TreeQueue)) {
        DeQueue(&TreeQueue,&p);

        if(p) {
            visit(p->data);
            EnQueue(&TreeQueue,p->lchild);
            EnQueue(&TreeQueue,p->rchild);
        }
    }

    return OK;
}