简单二叉树相关代码

#include <stdio.h>

typedef struct tagBinaryTree* Node;
typedef struct tagBinaryTree BinaryTree;

struct tagBinaryTree{
    int key;
    Node lchild;
    Node rchild;
    Node parent;
};
typedef struct                          //定义栈的结构体 
{ 
    Node          *base;              //在栈构造前和销毁后，base的值为NULL 
    Node          *top;               //栈顶指针 
    int             stacksize;          //当前已分配的存储空间，以元素为单位 
}Stack; 
int Key(Node branch)
{
    if(branch == NULL) return 0;
    return branch->key;
}

Node Left(Node branch)
{
    if(branch == NULL) return NULL;
    return branch->lchild;
}

Node Right(Node branch)
{
    if(branch == NULL) return NULL;
    return branch->rchild;
}

Node Parent(Node branch)
{
    if(branch == NULL) return NULL;
    return branch->parent;
}
Node LookUp(Node T, int key)
{
    while(T != NULL && Key(T) != key){
        if(key < Key(T)){
            T = Left(T);
        }else{
            T = Right(T);
        }
    }
    return T;
}
Node CreateLeaf(int x, Node* T)
{
    Node n = malloc(sizeof(BinaryTree));
    n->lchild = n->rchild = n->parent = NULL;
    
    n->key = x;
    *T = n;
    return n;
}

int InsertKey(int key, Node* T)
{
    Node root = *T,parent = NULL,x = NULL;
    x = LookUp(*T, key);
    if(x != NULL) return 0;
    CreateLeaf(key, &x);
    
    while(root != NULL){
        parent = root;
        if(key < Key(root)){
            root = Left(root);
        }else if(key > Key(root)){
            root = Right(root);
        }else{
            return 0;
        }
    }
    x->parent = parent;

    if(parent == NULL) {
        *T = x;
        return 0;
    }else if(key < Key(parent)){
        parent->lchild = x;
    }else{
        parent->rchild= x;
    }
    return 0;
}

int PreOrderTravel(Node T, Stack S)
{
    while( S.base != S.top|| T != NULL)       //判断栈和树是否为空 
    { 
        while( T !=NULL )                  //向左子树一直循环到最左的节点 
        { 
            printf("%d ",T->key);      //输出元素
            *S.top++ = T; 
            T = T->lchild; 
        } 
        T = *--S.top;                     //实现出栈 
        T = T->rchild;                    //转向右子树 
    } 
    printf("
");
    return 0; 
}
int InOder(Node T,Stack S)      //实现非递归中序遍历函数 
{ 
    while( S.base != S.top || T != NULL)       //判断栈和树是否为空 
    { 
        while(T!=NULL)                  //向左子树一直循环到最左的节点 
        { 
            *S.top++ = T; 
            T = T->lchild; 
        } 
        T = *--S.top;                     //实现出栈 
        printf("%d ", T->key);
        T = T->rchild;                  //转向右子树 
    } 
    printf("
");
    return 0; 
} 
        
int PostOrder(Node T,Stack S)   //实现非递归后序遍历函数 
{ 
    Node temp=NULL;                   //定义临时变量，用来标记刚刚访问过的节点 
    while( S.base != S.top || T!= NULL )      //判断栈和树是否为空 
    { 
        while(T!=NULL)                  //向左子树一直循环到最左的节点 
        { 
            *S.top++ = T; 
            T = T->lchild; 
        } 
        T = *(S.top-1);                   //取栈顶节点 
        if( T->rchild == NULL || T->rchild == temp) 
        {                               //如果该节点没有右孩子或者其右孩子刚刚被访问过 
            printf("%d ",T->key);      //输出元素
            S.top--;                    //已访问，使其出栈 
            temp=T;                     //标记为刚刚访问过 
            T=NULL;                     //若遍历完以该节点为根的子树，且栈空，则结束，否则继续 
        } else{
            T = T->rchild;                    //转向右子树 
        }
    } 
    printf("
");
    return 0; 
} 
int CreatStack(Stack* S)             //实现栈的建立函数 
{ 
    S->base=(Node*)malloc(100*sizeof(Node)); 
    if(!S->base)                         //判断是否建立失败 
        return -1; 
    S->top=S->base; 
    S->stacksize=100; 
    return 0; 
}
void DestoryStack(Stack* s)
{
    if(!s || !s->base){
        return ;
    }
    free(s->base);
    memset(s, 0, sizeof(Stack));
}
Node FollowNode(Node T, int key)
{
    Node cur = LookUp(T, key);
    
    if(cur->rchild){
        Node right = cur->rchild;
        while(right->lchild != NULL){
            right = right->lchild;
        }
        return right;
    }else if(Parent(cur)){
        Node parent= Parent(cur);
        while(parent != NULL && Right(parent) == cur ){
            cur=parent;
            parent = Parent(parent);
        }
        return parent;
    }
    return NULL;
}

Node PreNode(Node T, int key)
{
    Node cur = LookUp(T, key);
    if(cur->lchild){
        Node left = cur->lchild;
        while(left->rchild != NULL){
            left = left->rchild;
        }
        return left;
    }else if(Parent(cur)){
        Node parent = Parent(cur);
        while(parent != NULL && Left(parent) == cur){
            cur = parent;
            parent = Parent(parent);
        }
        return parent;
    }
    return NULL;
}
Node DeleteNode(Node* T, int key)
{
    Node cur = LookUp(*T, key);
    Node root = *T,old_cur = cur,  parent = NULL;
    
    if(root == NULL || cur == NULL){
        return *T;
    }
    parent = cur->parent;
    if(cur->lchild == NULL){
        cur = cur->rchild;
    }else if(cur->rchild == NULL){
        cur = cur->lchild;
    }else{
        Node right = cur->rchild;
        while(right->lchild != NULL){
            right = right->lchild;
        }
        cur->key = right->key;
        if(right->parent != cur){
            right->parent->lchild = right->rchild;
            if(right->rchild != NULL){
                right->rchild->parent = right->parent;
            }
        }else{
            cur->rchild = right->rchild;
            if(right->rchild != NULL){
                right->rchild->parent = right->parent;
            }
        }
        free(right);
        right = NULL;
        return root;
    }
    if(cur != NULL){
        cur->parent = parent;
    }else{
        //printf("cur is NULL
");
    }
    if(root == old_cur && root->lchild == NULL && root->rchild == NULL){
        *T = NULL;
        //do nothing
    }else if(parent == NULL){
        *T =root = cur;
    }else{
        if(parent->lchild == old_cur){
            parent->lchild = cur;
        }else{
            parent->rchild = cur;
        }
    }
    free(old_cur);
    old_cur = NULL;
    return root;
}

int main(int argc, char** argv)
{
    Node root = NULL, pNode = NULL;
    Stack stack = {0};
    int len = 0, i = 0;
    unsigned int tdata[21] = {30, 11, 71, 15, 9, 31, 12, 24, 18,10, 3,13, 14,33,80, 47,8,5,6,26};
    CreatStack(&stack);

    while(i < 20){
        InsertKey(tdata[i], &root);
        i++;
    }
    
    PreOrderTravel(root, stack);
    InOder(root,stack);
    PostOrder(root,stack);
    
    pNode = FollowNode(root, 30);
    printf("30 follow node:%d
", pNode->key);
    pNode = PreNode(root, 47);
    printf("47 pre node :%d
", pNode->key);
    DeleteNode(&root, 31);

    PreOrderTravel(root, stack);
    InOder(root,stack);
    PostOrder(root,stack);
    pNode = FollowNode(root, 30);
    printf("30 follow node:%d
", pNode->key);
    pNode = PreNode(root, 47);
    printf("47 pre node :%d
", pNode->key);
    
    i = 0;
    while(i < 20){
        DeleteNode(&root, tdata[i]);
        i++;
    }
    DestoryStack(&stack);
    return 0;
}