二叉树1

1.已知完全二叉树的层次遍历，求其前、中、后序

测试样例:

）

对于例1：

前序遍历:ABDGIJKLCEFH

中序遍历:DIGJLKBAECHF

后序遍历:ILKJGDBEHFCA

对于例2:

前序遍历:eadcbjfghi

中序遍历:abcdjefhgi

后序遍历:bcjdahigfe

//用顺序存储的方法将完全二叉树中的所有结点逐层存放在数组中R[1..n]
//若R[i]若有左结点,则左孩子的 结点编号为R[2i];若有右结点,则右孩子的编号为R[2i+1](证明暂略)
//0~n-1,R[2i+1],R[2i+2]

#include <stdio.h>
#include <stdlib.h>
#include <string.h> 
#define MAXSIZE 100+1
void Preordertraverse(char *data,int i)//中左右 
{
    if(data[i] == '#' || i >= strlen(data)) return;
    putchar(data[i]);
    Preordertraverse(data,2*i+1);
    Preordertraverse(data,2*i+2);
}
void Inordertraverse(char *data,int i)//左中右 
{
    if(data[i] == '#' || i >= strlen(data)) return;
    Inordertraverse(data,2*i+1);
    putchar(data[i]);
    Inordertraverse(data,2*i+2);
}
void Postordertraverse(char *data,int i)//左右中 
{
    if(data[i] == '#' || i >= strlen(data)) return;
    Postordertraverse(data,2*i+1);
    Postordertraverse(data,2*i+2);
    putchar(data[i]);
}
int main()
{
    char data[MAXSIZE];
    printf("完全二叉树的所有结点(以'#'代替空):"); 
    gets(data);
    //前 中 后序遍历 
    printf("前序遍历:");
    Preordertraverse(data,0);
    printf("\n中序遍历:");
    Inordertraverse(data,0);
    printf("\n后序遍历:");
    Postordertraverse(data,0);
    printf("\n");
    return 0;
}

//ABCD#EF#G####H###IJ###################K######################################L

//eaf#d#g##cj##hi####b

//R[0..n-1] ,R[2*i+1],R[2*i+2]
#include <stdio.h>
#include <stdlib.h>
#include <string.h> 
#define MAXSIZE 100+1
typedef struct node{
    char data;
    struct node *lchild,*rchild;
}bitree,*bitnode;
void Create_bitree(bitnode &bt,char *data,int i)//递归建树 
{
    if(i >= strlen(data) || data[i] == '#' || data[i] == '\0')    bt = NULL;
    else{
        bt->data = data[i];
        bt->lchild = (bitree *)malloc(sizeof(bitree)); 
        bt->rchild = (bitnode)malloc(sizeof(bitree));
        Create_bitree(bt->lchild,data,2*i+1);
        Create_bitree(bt->rchild,data,2*i+2);
    }
}
void Preordertraverse(bitree *bt)//中左右 
{
    if(!bt) return;
    putchar(bt->data);
    Preordertraverse(bt->lchild);
    Preordertraverse(bt->rchild);
}
void Inordertraverse(bitree *bt)//左中右 
{
    if(!bt) return;
    Inordertraverse(bt->lchild);
    putchar(bt->data);
    Inordertraverse(bt->rchild);
}
void Postordertraverse(bitree *bt)//左右中 
{
    if(!bt) return;
    Postordertraverse(bt->lchild);
    Postordertraverse(bt->rchild);
    putchar(bt->data);
}
int main()
{
    bitree *bt = (bitree *)malloc(sizeof(bitree));
    char data[MAXSIZE];
    printf("完全二叉树的所有结点(以'#'代替空):");
    gets(data); 
    Create_bitree(bt,data,0);
    //前 中 后序遍历 
    printf("前序遍历:");
    Preordertraverse(bt);
    printf("\n中序遍历:");
    Inordertraverse(bt);
    printf("\n后序遍历:");
    Postordertraverse(bt);
    printf("\n");
    return 0;
}

//非递归建立二叉树

//R[1..n],R[2i](左结点),R[2i+1](右结点)
//定义bitree*的一个 队列Q,以及下标front(初始为1),rear(初始为0),不断接收指针结点s,rear>=2(root指向Q[1])时,作两个判断(顺序不可反)
//1.s && Q[front]不为空,进行如下处理，rear(偶),s为Q[front]左孩子, 否则为右孩子
//2.rear为奇数(表示当前根结点左右孩子已经确定,应进入下一个结点的处理),front自增

bitree*creattree()
{
     bitree *root,*s;
     bitree *Q[maxsize];
     int front = 1,rear = 0;
     char ch;
     while((ch=getchar()) != '\n')//'\n'
     {
         s = NULL;
         if(ch != '#') 
         {
            s = (bitree *) malloc(sizeof(bitree));
            s->data = ch;
            s->lchild = NULL;
            s->rchild = NULL;
        }
        Q[++rear] = s;
        if(rear >= 2)
        {
            if(s && Q[front])
            {
                if(rear%2 == 0)  Q[front]->lchild = s;
                else Q[front]->rchild = s;
            } 
            if(rear%2)
                front ++;
        }
     }
     return root=Q[1];
}

//先序遍历加括号(加强层次感)

void Preordertraverse(bitree *p)
{
     if(p!=NULL)
     {
          printf("%c",p->data);
          if(p->lchild!=NULL||p->rchild!=NULL)
          {
               printf("(");
               Preordertraverse(p->lchild);
               if(p->rchild!=NULL && p->lchild != NULL)printf(",");
               Preordertraverse(p->rchild);
               printf(")");
          }
     }
}

//注意到:由于结点个数随着层数呈指数级增长,当层数过大而空结点较多时,能否不用数组辅助实现???请知道的朋友不吝告知