数据结构笔记3---二叉树

#include<stdio.h>
#include<stdlib.h>

typedef struct Tnode
{
    int x;
    struct Tnode *lchild,*rchild;
}tnode;


typedef struct TTnode
{
    tnode *node;
    int mark;
}ttnode;


/*****************************************插入结点data***********************************************************/
void insertnode(tnode *&tp,int data)
{
    tnode *p,*q,*node;//p指向待插入的位置,q指向待插入位置的父结点
    node=(tnode *)malloc(sizeof(tnode));
    node->x=data;
    node->lchild=node->rchild=NULL;
    if(tp==NULL)
    {    
        tp=node;
        return;
    }

    p=tp;
    while(p!=NULL)
    {
        q=p;
        if(data>p->x)
            p=p->rchild;
        else
            p=p->lchild;
    }
    if(data<q->x)
        q->lchild=node;
    else
        q->rchild=node;
    return;
}
/*************************************先序遍历的递归算法***************************************************************/
void preorder(tnode *tp)
{
    if(tp==NULL)
        return;
    printf("%d\n",tp->x);
    preorder(tp->lchild);
    preorder(tp->rchild);
}
/***************************************先序遍历的非递归算法1*************************************************************/
void iter_preorder(tnode *tp)
{
    tnode *tn[20],*q;
    int k=0;
    q=tp;
    tn[k++]=q;
    while(k>0)
    {
        q=tn[--k];
        printf("%d",q->x);
        if(q->rchild!=NULL)
            tn[k++]=q->rchild;
        if(q->lchild!=NULL)
            tn[k++]=q->lchild;
    }
}
/*************************************先序遍历的非递归算法2***************************************************************/
void iter_preorder2(tnode *tp)
{
    tnode* tn[20],*q;
    q=tp;
    int k=0;
    while((NULL!=q)||k>0)
    {
        if(NULL!=q)
        {
            printf("%d",q->x);
            tn[k++]=q;
            q=q->lchild;
        }
        else
        {
            q=tn[--k];
            q=q->rchild;
        }
    }
}
/************************************中序遍历的递归算法****************************************************************/
void inorder(tnode *tp)
{
    if(tp!=NULL)
    {
        inorder(tp->lchild);
        printf("%d\n",tp->x);
        inorder(tp->rchild);
    }
}
/**************************************中序遍历的非递归方式**************************************************************/
void iter_inorder(tnode *tp)
{
    tnode* tn[20],*node,*q;
    q=tp;
    int k=0;
    while((NULL!=q)||k>0)
    {
        if(NULL!=q)
        {
            tn[k++]=q;
            q=q->lchild;
        }
        else
        {
            q=tn[--k];
            printf("%d",q->x);
            q=q->rchild;
        }
    }

}

/************************************后序遍历的递归算法****************************************************************/
void postorder(tnode *tp)
{
    if(tp!=NULL)
    {
        inorder(tp->lchild);        
        inorder(tp->rchild);
        printf("%d\n",tp->x);
    }
}

/************************************后序遍历的非递归算法****************************************************************/
void iter_postorder(tnode *tp)
{
    ttnode a,b;
    ttnode mark_node[50];
    int k=0;
    a.node=tp;
    a.mark=0;
    mark_node[k++]=a;
    while(k>0)
    {
        //printf("%d\n",k);
        //a=mark_node[k-1];
        //printf("%d\n",k);
        switch(mark_node[k-1].mark)
        {
        case 0:
            mark_node[k-1].mark=1;
            //printf("%d\n",k);

            
            if(mark_node[k-1].node->lchild)
            {
                /*mark_node[k].node=a.node->lchild;
                mark_node[k].mark=0;
                k++;*/
                
                b.node=mark_node[k-1].node->lchild;
                b.mark=0;
                mark_node[k]=b;
                ++k;
                //printf("%d\n",k);
            }
            //printf("%d\n",k);
            break;
        case 1:
            mark_node[k-1].mark=2;
            if(mark_node[k-1].node->rchild!=NULL)
            {
                /*mark_node[k].node=a.node->rchild;
                mark_node[k].mark=0;
                k++;*/
                b.node=mark_node[k-1].node->rchild;
                b.mark=0;
                mark_node[k]=b;
                ++k;
            }
            break;
        case 2:
            {
                printf("%d",mark_node[k-1].node->x);
                --k;
            }
        }//switch



    }//while
    


}



/**************************************层次遍历二叉树*************************************************************/
void levpostorder(tnode *tp)
{
    tnode *q[20];
    tnode *p;
    int head=0,tail=0,i;
    q[tail++]=tp;
    while(head!=tail)
    {
        p=q[head];
        head=(head+1)%19;
        printf("%d",p->x);
        if(p->lchild!=NULL)
        {
            q[tail]=p->lchild;
            tail=(tail+1)%19;
        }
        if(p->rchild!=NULL)
        {
            q[tail]=p->rchild;
            tail=(tail+1)%19;
        }
    
    }
}
/****************************************交换每个结点的左、右儿子*********************************************************/
void swap(tnode *tp)
{
    tnode *q;
    if(tp!=NULL)
    {
        q=tp->lchild;
        tp->lchild=tp->rchild;
        tp->rchild=q;
        swap(tp->lchild);
        swap(tp->rchild);
    }
}

/****************************************删除指定结点data*********************************************************/
void deletenode(tnode *(&tp),int data)
{
    tnode *p,*q,*t,*s;
    q=NULL;
    p=tp;
    if(tp==NULL)
    {
        printf("树为空!不存在待删除的结点%d!\n",data);
        return ;
    }
    while(p!=NULL&&p->x!=data)
    {
        q=p;
        if(p->x>data)
            p=p->lchild;
        else
            p=p->rchild;
    }
    if(p==NULL)
    {
        printf("要删除的结点%d不存在!\n",data);
        return ;
    }
    
    if(p->lchild==NULL&&p->rchild==NULL)//如果待删除结点时叶子结点
    {
        if(p==tp)//如果待删除的结点是根结点
        {
            tp=NULL;
            free(p);
            p=NULL;            
        }
        else
        {
            if(p==q->lchild)
                q->lchild=NULL;
            else
                q->rchild=NULL;
            free(p);
            p=NULL;
        }
        return;
    }

    if(p->rchild==NULL)//如果待删除结点的右子树为空则只需要重接它的左子树
    {
        q=p->lchild;
        *p=*q;
        free(q);
        
    }
    else if(p->lchild==NULL)//如果待删除结点的左子树为空则只需要重接它的右子树
    {
        q=p->rchild;
        *p=*q;
        free(q);
    }
    else//如果待删除结点的左右子树都不为空
    {
        q=p;//q为s的父结点
        s=p->lchild;//s指向替换p的结点
        while(s->rchild!=NULL) 
        {
            q=s;
            s=s->rchild;
        }
        p->x=s->x;

        if(p==q)
        {
            q->lchild=s->lchild;
        }
        else
        {
            q->rchild=s->lchild;
        }
        free(s);
    }
    return ;
}
/****************************************************************************************************/

int main()
{
    int ia[6]={4,2,6,1,3,5};    
    //int ia[]={4};
    tnode *tp=NULL;
    int i;
    for(i=0;i<6;i++)
        insertnode(tp,ia[i]);

    //tnode *p,*q;
    //iter_postorder(tp);


    //deletenode(tp,6);
    //deletenode(tp,2);
    //deletenode(tp,3);
    
    //swap(tp);
    
    inorder(tp);
    system("pause");
}