数据结构——树

1.树的存储结构

（1）孩子存储结构

//二叉树孩子存储结构
typedef struct Branch
{
    int CIdx;
    Branch* next;
}Branch;

（2）二叉顺序存储结构

（3）二叉链式存储结构

//二叉链式存储结构
typedef struct BTNode
{
        int data;
        BTnode* lchild;
        BTnode* rchild;
}BTNode;

（4）树的孩子兄弟存储结构

//二叉树孩子兄弟存储结构
typedef struct BTNode
{

    int data;
    BTnode* child;
    BTnode* sbling;
}BTNode;

2.树，二叉树，森林的相互转化

（1）二叉树与树的互相转换

（2）森林与二叉树的转换

 3. 树，二叉树，森林的遍历

 

4.二叉树遍历代码

//二叉树递归遍历代码
void r(BTNode* p)
{
    if(p!=NULL)
        {
            vist(p);
            r(p->lchild);
            r(p->rchild);
        }
}

//二叉树先序非递归遍历
void preoerderNonrecursion(BTNode* bt)
{
    if(btt!=NULL)
        {
            BTNode* Stack[maxSize];
            int top=-1;
            BTNode* p=NULL;
            Stack[++top]=bt;
            while(top!=-1)
                {
                    p=Stack[top--];
                    visit(p);
                    if(p->child!=NULL)
                        Stack[++top]=p->rchild;
                    if(p->lchild!=nuLL)
                        Stack[++top]=p->lchild;      
                 }
                frre(p);
        }
}

//先序：   1，2，4，5，3，6，8，7
//逆后序： 1，3，7，6，8，2，5，4
//后序：   4，5，2，8，6，7，3，1
//二叉树后续非递归
void postorderrecursion(BTNode* bt)
{
    if(bt!==NULL)
    {
        BTNode* stack1[maxSize];int top1=-1;
        BTNode* stack1[maxSize];int top2=-1;
        BTode* p=NULL;
        stack1[++top1]=bt;
        while(top1!=-1)
        {
            p=stack1[top1--];
            stack2[++top2]=p;
            if(p->lchild!=NULL)
                stack1[++top1]=p->lchild;
            if(p->rchild!=NULL)
                stack1[++top1]=p->rchild;
        }
        while(top1!=-1)
        {
            p=stack2[top--];
            visit(p);
        }
    }
}

 

//二叉树中序非递归
void inorderNonrecursion(BTNode* bt)
{
    if(bt!=NULL)
    {
        BTNode* stack[maxSize];int top=-1;
        BTNode* p=NULL;
        p=bt;
        while(top!=-1||p!=NULL)
        {
            while(p!NULL)
            {
                stack[++top]=p;
                p=p->lchild;
            }
            if(top!=-1)
            {
                p=stack[top--];
                visit(p);
                p=p->rchild;
            }
        }
    }
}

 

//二叉树广度优先遍历（层次遍历）
void level(BTNode* bt)
{
    if(bt!=NULL)
    {
        int front,rear;
        BTnode* que[maxSize];
        front=rear=0;
        BTNode* p;
        rear=(rear+1)%maxSize;
        que[rear]=bt;
        while(front!=rear)
        {
            front=(front+1)%maxSize;
            p=que[front];
            visit(p);
            if(p->lchild!=NULL)
            {

                rear=(rear+1)%maxSize;
                que[rear]=p->lchild;
            }
            if(p->rchild!=NULL)
            {
                rear=(rear+1)%maxSize;
                que[rear]=p->rchild;

            }
        }

    }
}

5.树的遍历

 

//树的结构
typedef struct Branch
{
    int CIdx;
    Branch* next;

}Branch;

typedef struct
{
    int data;
    Branch* first;

}TNode;

//树的先序遍历
void peroder(TNode* p,TNode tree[])
{
    if(p!=NULL)
    {
        visit(p);
        Branch* q;
        q=p->first;
        while(q!=NULL)
        {
            preoder(&tree[q->CIdx],tree)
            q=q->next;
        }
    }
}

 

///树的广度优先（层次）遍历
void level(TNode* tn,TNode tree[])
{
    int front,rear;
    TNode* que[maxSize];
    front=rear=0;
    TBode* p;
    if(tn!=rear)
    {
        rear=(rear+1)%maxSize;
        que[rear]=tn;
        while(front!=rear)
        {
            front=(front+1)%maxSize;
            p=que[front];
            visit(p);
            Branch* q=p->first;
            while(q!=NULL)
            {

                rear=(rear+1)%maxSize;
                que[tree]=&tree[q->CIdx];
                q=q->next;
            }
        }
    }
}

 

6.线索二叉树

//线索二叉树
typedef struct TBTNode
{
    int data;
    int ltag;
    int rtag;
    TBTNode* lchild;
    TBTNode* echild;
}TBTNode;

//中序线索化
void inThread(TBTNode* p,TBTNode*& pre)

{
    if(p!NULL)
    {

        inThread(p->lchild,pre);
        if(p->child==NULL)
        {
            p->lchild=pre;
            p-ltag=1;

        }
        if(pre!=NULL&&pre->child==NULL)
        {

            pre->rchild=p;
            pre->rtag=1;
        }
        pre=p;
        inThread(p->rchild,pre);
    }
}

 

//前序线索化void preThread(TBTNode* p,TBTNode*& pre)
{
    if(p!=NULL)
    {
        if(p->lchild==NULL)
        {
            p->lchild=pre;
            p->ltag=1;

        }
        if(pre!=NULL&&pre->rchild==NULL)
        {
            pre->rchild=p;
            pre->rtag=1;
        }
        pre=p;
        preThread(p->lchild,pre);
        preThread(p->rchild,pre);
    }
}

//后序线索
void postThread(TBTNode* p,TBTNode* &pre)
{
    if(p!=NULL)
    {

        postThread(p->lchild,pre);
        postThread(p->rchild,pre);
        if(p->lchild==NULL)
        {

            p->lchild=pre;
            p->ltag=l;

        }
        if(pre!=NULL&&pre->rchild==NULL)
        {

            pre->rchild=p;
            pre->rtag=1;
        }
        pre=p;
    }
}

 

7.建树代码

//建树
BTNode*createBT ( char pre[],char in[],int L1,int R1,int L2,int R2 )
{
    if( L1>R1 )
        return NULL;
    BTNode* s=( BTNode* )malloc( sizeof ( BTNode ) );
    s->lchild=s->rchild=NULL;
    s->data=pre[L1];
    int i;
    for( i=L2;i<R2;i++ )
        if( int [i]==pre[L1] )
            break;
    s->lchild=createBT( pre , in , L1+1 , L1+i-L2,i-1,L2 );
    s->rchild=createBT( pre, in , L1+i-L2+1 , R1 , i+1 , R2 );
    return s;
}

//
BTNode* createBT2(char post[] ,char in[],int L1,int R1,int L2,int R2)
{
    if(L1>R1)
        return NULL;
    BTNode*s=( BTNode* )malloc(sizeof(BTNode));
    s->lchild=s->rchild=NULL;
    s->data=post[R1];
    int i;
    for(i=L2;i<=R2;++i)
        if(in[i]==post[R1])
            break;
    s->lchild=createBT2(post,in,L1,L1+i-L2-1,L2,i-1);
    s->rchild=createBT2((post,in,L1+i-L2,R1-1,i+1,R2);
    return s;
}



BTNode* createBT3(char level[],char in[],int n,int L,int R)
{
    if(L>R)
        return NULL;
    BTNode*s=(BTNode*)malloc(sizeof(BTNode));
    s->lchild=s->rchild=NULL;
    s->data=level[0];
    int i=search(in,level[0],L,R);
    int LN=i-L,char Llevel[LN];

    int RN=R-i;charRlevel[RN] ;
    getSubLevel(LLevel,level,in,n,L,i-1);
    getSubLevel(RLevel,level,in,n,i+1,R);
    s->lchild=createBT3(LLevel,in,LN,L,i-1);
    s->rchild=createBT3(RLevel,in,RN,i+1,R);
    return s;
}

 

8.二叉树遍历顺序问题

int search(char arr[],char key,int L,int R)
{
    int idx;
    for(idx=L;idx<=R;++idx)
        if(arr[idx]==key)
            return idx;
    return -1;
}


//
void getSubLevel(char subLeve[],char level[];char in[],int L;int R)
{
    int k=0;
    for(int i=0;i<n;++i)
        if(search(in,level[i],L,R)!=-1)
            subLevel([k++]=level[i]);
}

9.树的应用——表达式