二叉树-题-后序输入，前序输出

后序输入，前序输出

…D…H.EB…F…GCA

ABDEHCFG

一

#include <iostream>
#include <cstdlib>
#include <stack>
using namespace std;

typedef struct TreeNode *Tree;
typedef  char ElementType;
stack<char> sta;

struct TreeNode {
    ElementType Element;
    Tree Left;
    Tree Right;
};

typedef struct node{                //最大堆结构
    char array[100];
    int capacity;
    int size;
}Maxtree;
Maxtree createHeap(){                //初始化最大堆
    Maxtree tmp;
    tmp.array[0]=97;                //哨兵
    tmp.capacity=100;
    tmp.size=1;
    return tmp;
}
Maxtree MaxHeap=createHeap();
Tree CreateTree() {                      //后序建立二叉树
    char c = sta.top();             
    sta.pop();
    Tree T = (Tree)malloc(sizeof(struct TreeNode));
    if (c == '.') { 
        T = NULL;
    } else {
        T->Right = CreateTree();
        T->Left = CreateTree();
        T->Element = c;
    }
    return T;
}
Maxtree insertHeap(Maxtree tmp,char c){            //最大堆插入
    int t=tmp.size++;
    if (t>tmp.capacity)  return tmp; 
    while(tmp.array[t/2]<c){     
        tmp.array[t]=tmp.array[t/2];
        t=t/2;
    }
    tmp.array[t]=c;
    return tmp;
}
void Transform(Tree T) {                          //二叉树调整成最大堆
    if (!T) return;
    MaxHeap=insertHeap(MaxHeap,T->Element);
    Transform(T->Left);
    Transform(T->Right);
}

void Output(Tree T)                 //先序遍历输出二叉树
{
	if(T!=NULL)
	{
		// T->Element = c;
		printf("%c",T->Element);
		Output(T->Left);
		Output(T->Right);
	}
}
int main(int argc, char const *argv[]) {
    char c;
	
    for (int i = 0; i < 17; i++) 
	{ //6个节点，故2*6+1
        cin >> c;
        sta.push(c);
    }
    Tree T = CreateTree();
    Transform(T);
	Output(T);
    return 0;
}

二
stack.h：

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
 
#define TRUE	1
#define FALSE	0
#define ERROR	0
#define OK		1
#define STACK_INIT_SIZE		100
#define STACKINCREMENT		10
 
typedef int Status;
 
typedef struct {
	SElemType *base;
	SElemType *top;
	int stacksize;
}SqStack;
 
Status InitStack(SqStack *);
Status DestroyStack(SqStack *);
Status StackEmpty(SqStack);
SElemType GetTop(SqStack );
Status Push(SqStack *,SElemType );
SElemType Pop(SqStack *);
 
Status InitStack(SqStack *S) {
	S->base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
	S->top = S->base;
	S->stacksize = STACK_INIT_SIZE;
	return OK;
}
 
Status DestroyStack(SqStack *S) {
	if(S->base) 
		free(S->base);
	S->top = S->base = NULL;
	return OK;
}
 
Status StackEmpty(SqStack S) {
	if(S.top == S.base) 
		return TRUE;
	else
		return FALSE;
}
 
SElemType GetTop(SqStack S) {
	SElemType e;
	if(S.top == S.base)
		return ERROR;
	e = *(S.top-1);
	return e;
}
 
Status Push(SqStack *S,SElemType e) {
	if(S->top - S->base >= S->stacksize) {
		S->base = (SElemType *)realloc(S->base, (S->stacksize + STACKINCREMENT) * sizeof(SElemType));
		S->top = S->base + S->stacksize;
		S->stacksize += STACKINCREMENT;
	}
	*S->top++ = e;
	return OK;
}
 
SElemType Pop(SqStack *S) {
	SElemType e;
	if(S->top == S->base)
		return ERROR;
	e = *(--S->top);
	return e;
}

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<string.h>
 
#define OK		1
#define ERROR	0
 
typedef int Status;
typedef char TElemType;

typedef struct BiTNode 
{
	TElemType data;
	struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;
 
typedef char SElemType;
 
#include"stack.h"
SqStack S; 
 
Status InitBiTree(BiTree *);//建立

BiTree PreCreateBiTree(BiTree *);		//先序扩展序列递归建树 

BiTree PostCreateBiTree(BiTree *);		//后序扩展序列建树准备工作 
BiTree PostCreateBiTree2(BiTree *);		//后序扩展序列递归建树

Status PreOrder(BiTree );

int main() 
{
	BiTree BT;
	int flag = 1, select = 0;
	InitStack(&S);
	InitBiTree(&BT);
	while(1) 
	{
		BT = PostCreateBiTree(&BT);
		break;
	}
	//printf("Create BiTree successfully!\n\n");
	PreOrder(BT);
	return 0;
} 
 

Status InitBiTree(BiTree *BT) {
	*BT = NULL;
}
 
//先序扩展序列递归建树 
BiTree PreCreateBiTree(BiTree *BT) {
	TElemType ch;
	scanf("%c", &ch);
	
	if(ch == '#') {
		*BT = NULL;
		return *BT;
	}
	else {
		*BT = (BiTNode *)malloc(sizeof(BiTNode));
		(*BT)->data = ch;
		(*BT)->lchild = PreCreateBiTree(&((*BT)->lchild));
		(*BT)->rchild = PreCreateBiTree(&((*BT)->rchild));
	}
	
	return *BT;
}
 
//后序扩展序列建树准备工作，接收字符入栈 
BiTree PostCreateBiTree(BiTree *BT) {
	TElemType ch;
	scanf("%c", &ch);
	Push(&S, ch); 
	
	while(1) {
		scanf("%c", &ch);
		if(ch == '\n')
			break;
		
		Push(&S, ch); 
	}
	*BT = PostCreateBiTree2(&(*BT));
	return *BT;
}
 
//后序扩展序列递归建树
BiTree PostCreateBiTree2(BiTree *BT) {
	TElemType ch;
	ch = Pop(&S); 
	if(ch == '#') {
		*BT = NULL;
		return *BT;
	}
	else {
		*BT = (BiTNode *)malloc(sizeof(BiTNode));
		(*BT)->data = ch;	
		(*BT)->rchild = PostCreateBiTree2(&((*BT)->rchild));
		(*BT)->lchild = PostCreateBiTree2(&((*BT)->lchild));
	}
	
	return *BT;
}
 
Status PreOrder(BiTree BT) {
	if(BT) {
		if(!(BT->data))
			return ERROR;
		printf("%c ", BT->data);
		PreOrder(BT->lchild);
		PreOrder(BT->rchild);
		return OK; 
	}
	return ERROR;
}