王道数据结构代码题（C语言）二叉树

1.

#include 
#include 



void createBiTree(int *arr,int count) {//创建二叉树  
	int i = 1, data;
	//int *arr = (int *)malloc(sizeof(int)*(count + 2));
	while(count--){
        printf("请输入第%d个结点：", i);    // 输入9999代表空结点
        scanf("%d", &data);
        *(arr + i) = data;
        i++;
	}
}

int findCommonAncestor(int *arr,int i,int j){
    while(i != j){
            if(i > j){
                i = i / 2;
            }
            else{
                j = j / 2;
            }
    }
    return *(arr + i);
}

int main() {
	void createBiTree(int *, int);
	int count, i, j;
	printf("请输入要创建的二叉树，其转换为完全二叉树的最少结点数：count=");
	scanf("%d", &count);
	int *arr = (int *)malloc(sizeof(int)*(count + 2));
	createBiTree(arr, count);
	printf("请输入要查找公共结点的两个结点的编号，编号<=%d\n", count);
	printf("i=");
	scanf("%d", &i);
	printf("\n");
	printf("j=");
	scanf("%d", &j);
	while(i > count || j > count || *(arr + i) == 9999 || *(arr + j) == 9999){
        printf("编号有误，请重新输入：\n");
        printf("i=");
        scanf("%d", &i);
        printf("\n");
        printf("j=");
        scanf("%d", &j);
	}
	count = findCommonAncestor(arr, i, j);
	printf("公共祖先为：%d", count);
	return 0;
}

2. 创建链式二叉树

#include 
#include 
#define TYPE char
typedef struct BiTree{
    TYPE data;
    struct BiTree *lchild, *rchild;
}BiTree;


// 创建一颗二叉树(先序输入），‘#’号为空结点
BiTree *createBiTree(BiTree *T) {
	TYPE data; // 当前结点值
	printf("请输入当前结点值：data=");   
	scanf("%c", &data);      // 先序输入，‘#’号为空结点
	getchar();
	if(data != '#'){  //
        T = (BiTree *)malloc(sizeof(BiTree *));
        T->data = data;
        T->lchild = NULL;
        T->rchild = NULL;
        T->lchild = createBiTree(T->lchild);
        T->rchild = createBiTree(T->rchild);
	}
	return T;
}

// 先序遍历
void preOrder(BiTree *T){
    if(T != NULL){
        printf("%c", T->data);
        preOrder(T->lchild);
        preOrder(T->rchild);
    }
}

// 中序遍历
void inOrder(BiTree *T){
    if(T != NULL){
        inOrder(T->lchild);
        printf("%c", T->data);
        inOrder(T->rchild);
    }
}

// 后序遍历
void postOrder(BiTree *T){
    if(T != NULL){
        postOrder(T->lchild);
        postOrder(T->rchild);
        printf("%c", T->data);
    }
}


int main() {
    BiTree *T = (BiTree *)malloc(sizeof(BiTree *));
    T = createBiTree(T);
    inOrder(T);
	return 0;
}

3.二叉树的遍历（递归与非递归）

#include 
#include 

#define MAXSIZE 100


// 二叉树的实现

// 定义 二叉树的 结构体
typedef struct node{
	char data;
	struct node *left;
	struct node *right;
}Node, *Tree;

// 依据前序遍历创建二叉树
// 根左右： ABD##E##C##

Tree create_tree(){
	Node *root = NULL;
	char ch;
	scanf("%c", &ch); // 输入 ABD##E##C##

	if (ch != '#'){
		root = (Node*)malloc(sizeof(Node));
		root->data = ch;

		root->left = create_tree(); // 递归创建
		root->right = create_tree();
	}
	else{
		root = NULL;
	}

	return root;
}


// 递归前序遍历二叉树
void preOrderRec(Tree root){
	if (root != NULL){
		printf(" %c  ", root->data);
		preOrderRec(root->left);
		preOrderRec(root->right);
	}
}

// 非-递归前序遍历二叉树
void preOrderNRec(Tree root){
	Tree stack[MAXSIZE], node;
	int top = 0;

	if (root == NULL){
		printf("tree is empty-- \n");
		return;
	}
	else{
		top++;
		// 仿照一个栈
		stack[top] = root; // 将根节点入栈
		while (top > 0){
			//出栈
			node = stack[top--];
			printf(" %c  ", node->data);

			// 先把右子树放进去，栈是先进去后出，所以下面的左子树先出
			if (node->right != NULL){
				stack[++top] = node->right;  // 入栈
			}
			if (node->left != NULL){
				stack[++top] = node->left;
			}

		}

	}
}


// 递归中序遍历二叉树
void inOrderRec(Tree root){
	if (root != NULL){
		inOrderRec(root->left);
		printf(" %c  ", root->data);
		inOrderRec(root->right);
	}
}

// 非-递归实现中序遍历二叉树
void inOrderNRec(Tree root){
	Tree stack[MAXSIZE], node;
	int top = 0;
	// 判断树是否为空
	if (root == NULL){
		printf("tree is empty-- \n");
		return;
	}
	node = root;

	while (node != NULL || top > 0){

		// 将所有的左子树节点入栈
		while (node != NULL){
			stack[++top] = node;
			node = node->left;
		}
		//  如果右节点为空的话，执行下列语句
		node = stack[top--];
		printf(" %c  ", node->data);

		// 扫描右节点
		node = node->right;
	}

}


// 递归后序遍历二叉树
void backOrderRec(Tree root){
	if (root != NULL){
		backOrderRec(root->left);
		backOrderRec(root->right);
		printf(" %c  ", root->data);

	}
}

// 非 - 递归实现后序遍历
void backOrderNRec(Tree root){

	Node *p = root;
	Node *stack[MAXSIZE];
	int num = 0;
	Node *have_visited = NULL;

	while (NULL != p || num>0)
	{
		while (NULL != p)
		{
			stack[num++] = p;
			p = p->left;
		}
		p = stack[num - 1];
		if (NULL == p->right || have_visited == p->right)
		{
			printf(" %c  ", p->data);
			num--;
			have_visited = p;
			p = NULL;
		}
		else
		{
			p = p->right;
		}
	}

}

void backOrderNRecSimple(Tree root){
	Tree stack[MAXSIZE], node;
	int top = 0;
	int count = 0;
	char array[MAXSIZE]; // 使用一个数组来保存数据，方便最后数组的反转

	if (root == NULL){
		printf("tree is empty-- \n");
		return;
	}
	else{
		top++;
		// 仿照一个栈
		stack[top] = root; // 将根节点入栈
		while (top > 0){
			//出栈
			node = stack[top--];
			array[count++] = node->data; // 将其保存在一个数组当中

			// 先把右子树放进去，栈是先进去后出，所以下面的左子树先出
			if (node->left != NULL){
				stack[++top] = node->left;  // 入栈
			}
			if (node->right != NULL){
				stack[++top] = node->right;
			}

		}

	}
	// 反转数组，输出
	for (int i = count-1; i >= 0; i--){
		printf(" %c  ", array[i]);
	}

}

// 层次遍历，打印出二叉树的值
void Level_traversal(Tree root){

	if (root == NULL){
		printf("tree is empty-- \n");
		return;
	}

	Tree stack[MAXSIZE], node;
	node = root;
	int front = 0;  // 使用 front， rear模拟队列
	int rear = 0;

	stack[rear++] = node;

	while (front != rear){

		node = stack[front++]; // 模拟队列，先获取front当前元素，然后在指向 front ++ 位元素
		printf(" %c  ", node->data);

		// 左右子树入队列
		if (node->left != NULL){
			stack[rear++] = node->left;
		}

		if (node->right != NULL){
			stack[rear++] = node->right;
		}
	}

}


int main(){

	printf("请输入二叉树序列（前序输入）: \n");  // ABD##E##C##


	Tree root = create_tree();
	printf("递归前序遍历\n");
	preOrderRec(root);
	printf("\n");
	printf("递归中序遍历\n");
	inOrderRec(root);
	printf("\n");
	printf("递归后序遍历\n");
	backOrderRec(root);
	printf("\n");
	printf("\n");

	printf("非递归实现前序遍历\n");
	preOrderNRec(root);
	printf("\n");
    printf("\n");
	printf("非递归实现中序遍历 \n");
	inOrderNRec(root);
	printf("\n");

	printf("非递归实现后序遍历 \n");
	backOrderNRec(root);
	printf("\n");

	printf("非递归实现后序遍历  简单的方法  \n");
	backOrderNRecSimple(root);
	printf("\n");

	printf("层次遍历\n");
	Level_traversal(root);
	printf("\n");

	return 0;
}

补充：

①.非递归前序遍历二叉树
  前序遍历顺序是：根-左-右
  先打印根节点的值，由于栈是先进后出，所以先将 右子树放进去，再将左子树放进去。
②.非递归实现中序遍历二叉树
  中序遍历的非递归方式实现思想是：
   a.从根结点开始，遍历左孩子同时压栈，当遍历结束，说明当前遍历的结点没有左孩子。

  b.从栈中取出来调用操作函数，然后访问该结点的右孩子，继续以上重复性的操作。
③.非递归实现后序遍历【简单的方法】
  我们知道 后序遍历的顺序为：
  后序：左->右->根
  那么可以把后序当作：根->右->左，最后再反转回来即可。
  由于我们是使用的栈，所以先保存根节点， 然后先放进去左节点，再放进去右节点。

4.

#include 
#include 

#define MAXSIZE 100


// 二叉树的实现

// 定义 二叉树的 结构体
typedef struct node{
	char data;
	struct node *left;
	struct node *right;
}Node, *Tree;

// 依据前序遍历创建二叉树
// 根左右： ABD##E##C##

Tree create_tree(){
	Node *root = NULL;
	char ch;
	scanf("%c", &ch); // 输入 ABD##E##C##

	if (ch != '#'){
		root = (Node*)malloc(sizeof(Node));
		root->data = ch;

		root->left = create_tree(); // 递归创建
		root->right = create_tree();
	}
	else{
		root = NULL;
	}

	return root;
}


// 递归后序遍历二叉树
void backOrderRec(Tree root){
	if (root != NULL){
		backOrderRec(root->left);
		backOrderRec(root->right);
		printf(" %c  ", root->data);

	}
}

// 非 - 递归实现后序遍历
void backOrderNRec(Tree root){

	Node *p = root;
	Node *stack[MAXSIZE];
	int num = 0;
	Node *have_visited = NULL;

	while (NULL != p || num>0)
	{
		while (NULL != p)
		{
			stack[num++] = p;
			p = p->left;
		}
		p = stack[num - 1];
		if (NULL == p->right || have_visited == p->right)
		{
			printf(" %c  ", p->data);
			num--;
			have_visited = p;
			p = NULL;
		}
		else
		{
			p = p->right;
		}
	}

}

void backOrderNRecSimple(Tree root){
	Tree stack[MAXSIZE], node;
	int top = 0;
	int count = 0;
	char array[MAXSIZE]; // 使用一个数组来保存数据，方便最后数组的反转

	if (root == NULL){
		printf("tree is empty-- \n");
		return;
	}
	else{
		top++;
		// 仿照一个栈
		stack[top] = root; // 将根节点入栈
		while (top > 0){
			//出栈
			node = stack[top--];
			array[count++] = node->data; // 将其保存在一个数组当中

			// 先把右子树放进去，栈是先进去后出，所以下面的左子树先出
			if (node->left != NULL){
				stack[++top] = node->left;  // 入栈
			}
			if (node->right != NULL){
				stack[++top] = node->right;
			}

		}

	}
	// 反转数组，输出
	for (int i = count-1; i >= 0; i--){
		printf(" %c  ", array[i]);
	}

}



int main(){

	printf("请输入二叉树序列（前序输入）: \n");  // ABD##E##C##

	Tree root = create_tree();

	printf("递归实现后序遍历 \n");
	backOrderNRec(root);
	printf("\n");

	printf("非递归实现后序遍历  简单的方法  \n");
	backOrderNRecSimple(root);
	printf("\n");

	return 0;
}

5.

/*
  C++实现
*/
#include
#include
#include
using namespace std;

#define MaxSize 100
typedef int ElemType;
typedef struct BiNode {
	ElemType data;
	BiNode* lchild;
	BiNode* rchild;

}BiNode, *BiTree;

//构建二叉树
BiNode* Create(BiNode* bt) {
	static int i = 0;
	char ch;
	//string str = "AB#D##C##";
	//string str = "124##56##7##3##";
	string str = "ABD#G##E##CF###";      // 示例
	ch = str[i++];
	if (ch == '#')bt = NULL;//建立一棵空树
	else {
		bt = (BiTree)malloc(sizeof(BiNode)); bt->data = ch;//生成一个结点，数据域为ch
		bt->lchild = Create(bt->lchild);//递归建立左子树
		bt->rchild = Create(bt->rchild);//递归建立右子树
	}
	return bt;
}

void visit(int x) {
	printf("%c ", x);
}

typedef struct {
	BiTree data[MaxSize];//存放栈中元素
	int top;//栈顶指针
}SqStack;

//（1）初始化
void InitStack(SqStack& S) {
	S.top = -1;//初始化栈顶指针
}
//（2）判栈空
bool IsEmpty(SqStack& S) {
	if (S.top == -1) {//栈空
		return true;
	}
	else {//不空
		return false;
	}
}
//（3）进栈
bool Push(SqStack& S, BiTree& p) {
	if (S.top == MaxSize - 1) {//栈满，报错
		return false;
	}
	S.data[++S.top] = p;//指针先加1，再加入栈
	return true;
}
//（4）出栈
bool Pop(SqStack& S, BiTree& p) {
	if (S.top == -1) {//栈空，报错
		return false;
	}
	p = S.data[S.top--];//先出栈，指针再减1
	return true;
}
//（5）读栈顶元素
bool GetTop(SqStack& S, BiTree& p) {
	if (S.top == -1) {//栈空，报错
		return false;
	}
	p = S.data[S.top];//先出栈，指针再减1
	return true;
}

typedef struct {
	BiTree data[MaxSize];//存放队列元素
	int front, rear;//队头指针和队尾指针
}SqQueue;

//循环队列的操作

//初始化
void InitQueue(SqQueue &Q) {
	Q.rear = Q.front = 0;//初始化队首、队尾指针
}

//判断队空
bool QIsEmpty(SqQueue Q) {
	if (Q.rear == Q.front) {//队空条件
		return true;
	}
	else {
		return false;
	}
}

//入队
bool EnQueue(SqQueue &Q, BiTree &p) {
	if ((Q.rear + 1) % MaxSize == Q.front)//队满则报错
		return false;
	Q.data[Q.rear] = p;
	Q.rear = (Q.rear + 1) % MaxSize;//队尾指针加1取模
	return true;
}

//出队
bool DeQueue(SqQueue& Q, BiTree& p) {
	if (Q.rear == Q.front)//队空则报错
		return false;
	p = Q.data[Q.front];
	Q.front = (Q.front + 1) % MaxSize;//队头指针加1取模
	return true;
}

void LevelOrder(BiTree bt) {
	SqQueue Q;
	BiNode* p;
	if (bt != NULL) {
		InitQueue(Q);//队列初始化，队列中存放二叉树结点的指针
		EnQueue(Q, bt);
		while (QIsEmpty(Q) == false) {//从上而下层次遍历
			DeQueue(Q, p);
			visit(p->data);
			if (p->lchild)
				EnQueue(Q, p->lchild);//若左子女不空，则入队列
			if (p->rchild)
				EnQueue(Q, p->rchild);//若右子女不空，则入队列
		}
	}//if结束
}

void InvertLevel(BiTree bt) {
	SqStack S;
	SqQueue Q;
	BiNode* p;
	if (bt != NULL) {
		InitStack(S);//栈初始化，栈中存放二叉树结点的指针
		InitQueue(Q);//队列初始化，队列中存放二叉树结点的指针
		EnQueue(Q, bt);
		while (QIsEmpty(Q) == false) {//从上而下层次遍历
			DeQueue(Q, p);
			Push(S, p);//出队，入栈
			if (p->lchild)
				EnQueue(Q, p->lchild);//若左子女不空，则入队列
			if (p->rchild)
				EnQueue(Q, p->rchild);//若右子女不空，则入队列
		}
		while (IsEmpty(S) == false) {
			Pop(S, p);
			visit(p->data);
		}//自下而上，从右到左的层次遍历
	}//if结束
}

int main() {
	//创建一棵二叉树
	BiTree T = (BiTree)malloc(sizeof(BiNode));//创建一颗二叉树
	T = Create(T);
	//自上而下、从左到右的层序遍历
	printf("自上而下、从左到右的层序遍历 \n");
	LevelOrder(T);

	printf("\n自下而上、从右到左的层序遍历 \n");
	//自下而上、从右到左的层序遍历
	InvertLevel(T);
}

6.

/*
  C++实现
*/
#include
#include
#include
using namespace std;

#define MaxSize 100
typedef int ElemType;
typedef struct BiNode {
	ElemType data;
	BiNode* lchild;
	BiNode* rchild;

}BiNode, * BiTree;

//构建二叉树
BiNode* Create(BiNode* bt) {
	static int i = 0;
	char ch;
	//string str = "AB#D##C##";             // 二叉树示例
	//string str = "124##56##7##3##";
	//string str = "ABD#G##E##CF###";
	string str = "ABD##E#GI#KL####CF#H#J###";
	ch = str[i++];
	if (ch == '#')bt = NULL;//建立一棵空树
	else {
		bt = (BiTree)malloc(sizeof(BiNode));
		bt->data = ch;//生成一个结点，数据域为ch
		bt->lchild = Create(bt->lchild);//递归建立左子树
		bt->rchild = Create(bt->rchild);//递归建立右子树
	}
	return bt;
}

void visit(int x) {
	printf("%c ", x);
}

typedef struct {
	BiTree data[MaxSize];//存放队列元素
	int front, rear;//队头指针和队尾指针
}SqQueue;

//循环队列的操作

//初始化
void InitQueue(SqQueue& Q) {
	Q.rear = Q.front = 0;//初始化队首、队尾指针
}

//判断队空
bool QIsEmpty(SqQueue Q) {
	if (Q.rear == Q.front) {//队空条件
		return true;
	}
	else {
		return false;
	}
}

//入队
bool EnQueue(SqQueue& Q, BiTree& p) {
	if ((Q.rear + 1) % MaxSize == Q.front)//队满则报错
		return false;
	Q.data[Q.rear] = p;
	Q.rear = (Q.rear + 1) % MaxSize;//队尾指针加1取模
	return true;
}

//出队
bool DeQueue(SqQueue& Q, BiTree& p) {
	if (Q.rear == Q.front)//队空则报错
		return false;
	p = Q.data[Q.front];
	Q.front = (Q.front + 1) % MaxSize;//队头指针加1取模
	return true;
}



//非递归算法求二叉树的高度
int btDepth(BiTree T) {
	//采用层次遍历的非递归方法求解二叉树的高度
	if (!T)//树空，高度为0
		return 0;
	int front = -1, rear = -1;
	int last = 0, level = 0;//last指向下一层第一个结点的位置
	BiTree Q[MaxSize];//设置队列Q，元素是二叉树结点指针且容量足够
	Q[++rear] = T;//将根结点入队
	BiTree p;
	while (front < rear) {
		p = Q[++front];//队列元素出队，即正在访问的结点
		if (p->lchild)
			Q[++rear] = p->lchild;//左孩子入队
		if (p->rchild)
			Q[++rear] = p->rchild;//右孩子入队
		if (front == last) {
			level++;
			last = rear;
		}
	}
	return level;
}

//非递归算法求二叉树的高度
int btDepth1(BiTree T) {
	//采用层次遍历的非递归方法求解二叉树的高度
	if (!T)//树空，高度为0
		return 0;
	int last = 1, level = 0;//last指向下一层第一个结点的位置
	BiTree p;
	SqQueue Q;//设置队列Q
	InitQueue(Q);

	EnQueue(Q, T);//将根结点入队
	while (Q.front < Q.rear) {
		DeQueue(Q,p);//队列元素出队，即正在访问的结点
		if (p->lchild)
			EnQueue(Q,p->lchild);//左孩子入队
		if (p->rchild)
			EnQueue(Q, p->rchild);//右孩子入队
		if (Q.front == last) {
			level++;
			last = Q.rear;
		}
	}
	return level;
}

//递归算法求二叉树的高度
int DbtDepth(BiTree T) {
	int ldep, rdep;
	if (T == NULL)
		return 0;
	/*if (T->lchild) {
		cout << "开始左" ;
		visit(T->lchild->data);
		cout << endl;
	}*/
	ldep = DbtDepth(T->lchild);

	/*if (T->rchild) {
		cout << "开始右" ;
		visit(T->rchild->data);
		cout << endl;
	}*/
	rdep = DbtDepth(T->rchild);

	/*cout << "ldep = " << ldep << endl;
	cout << "rdep = " << rdep << endl*/;
	if (ldep > rdep) {
		return ldep + 1;
	}
	else {
		return rdep + 1;
	}
}

int main() {
	//创建一棵二叉树
	BiTree T = (BiTree)malloc(sizeof(BiNode));//创建一颗二叉树
	T = Create(T);
	//递归算法求二叉树的高度
	printf("递归求二叉树高度为：%d\n",DbtDepth(T));
	//非递归算法求二叉树的高度（一）
	printf("非递归（方法一）求二叉树高度为：%d\n",btDepth(T));
	//非递归算法求二叉树的高度（二）
	printf("非递归（方法二）求二叉树高度为：%d\n",btDepth1(T));
}

7.

方法1：

/*
  先序：ABCDEFG
  中序：CDBAEFG
*/
#include 
#include 
#include 

typedef char DataType;
typedef struct BiTNode
{
    DataType data;
    struct BiTNode *lchild, *rchild;
}LinkBiTree;


// 根据先序、中序序列构建二叉树
void CreateBiTree(LinkBiTree **T, char *PreStr, char *InStr, int L1, int R1, int L2, int R2)
{
    /* int i;
    printf("先序序列:");
    for (i = L1; i <= R1; i++){printf("%c ", PreStr[i]);}
    printf("\n中序序列:");
    for (i = L2; i <= R2; i++){printf("%c ", InStr[i]);}
    printf("\n"); */

    // 创建新的结点
    (*T) = (LinkBiTree *)malloc(sizeof(LinkBiTree));
    // 新结点数据为设置 先序序列 的第一个数据，即根节点数据
    (*T)->data = PreStr[L1];

    // 根据先序第一个元素为根结点元素，寻找中序序列中的根结点位置
    int root;
    for (root = 0; root <= R2; root++)
    {
        if (PreStr[L1] == InStr[root])
        {
            printf("先序序列根节点(%c)在中序的位置 = %d\n", PreStr[L1], root);
            break;
        }
    }



    // 判断中序序列中的左边是否存在左子序列
    if (root - L2 != 0)
    {
        // 划分两个区间，先序序列左子树区间 和 中序序列左子树区间，递归构建左子树

        /* printf("\t划分先序序列的左子树区间：[%d, %d] = > ", L1 + 1, L1 + (root - L2));
        for (i = L1 + 1; i <= L1 + (root - L2); i++){printf("%c ", PreStr[i]);}
        printf("\n");

        printf("\t划分中序序列的左子树区间：[%d, %d] = > ", L2, root - 1);
        for (i = L2; i <= root - 1; i++){printf("%c ", InStr[i]);}
        printf("\n"); */

        CreateBiTree(&(*T)->lchild, PreStr, InStr, L1 + 1, L1 + (root - L2), L2, root - 1);
    }
    else
    {
        (*T)->lchild = NULL;
    }

    // 判断中序序列中的右边是否存在右子序列
    if (R2 - root != 0)
    {
        // 划分两个区间，先序序列右子树区间 和 中序序列右子树区间，递归构建右子树

        /* printf("\t划分先序序列的右子树区间：[%d, %d] = > ", L1 + 1, L1 + (root - L2));
        for (i = R1 - (R2 - root) + 1; i <= R1; i++){printf("%c ", PreStr[i]);}
        printf("\n");

        printf("\t划分中序序列的右子树区间：[%d, %d] = > ", L2, root - 1);
        for (i = root + 1; i <=  R2; i++){printf("%c ", InStr[i]);}
        printf("\n"); */

        CreateBiTree(&(*T)->rchild, PreStr, InStr, R1 - (R2 - root) + 1, R1, root + 1, R2);
    }
    else
    {
        (*T)->rchild = NULL;
    }
}

// 后序遍历二叉树
void PostOrderTraverse(LinkBiTree *T)
{
    if (T)
    {
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        printf("%c ", T->data);
    }
}


int main()
{
    char PreStr[30], InStr[30];

    // 参考用例：ABCDEFG
    printf("请输入先序序列:");	//测试用例：ABDEHJKLMNCFGI
    scanf("%s", PreStr);
    //参考用例：CBDAEFG
    printf("请输入中序序列:");	//测试用例：DBJHLKMNEAFCGI
    scanf("%s", InStr);

    int len1 = strlen(PreStr);
    int len2 = strlen(InStr);

    LinkBiTree *T;
    CreateBiTree(&T, PreStr, InStr, 0, len1 - 1, 0, len2 - 1);


    printf("后序遍历二叉树:");
    PostOrderTraverse(T);
    printf("\n");

    return 0;
}

方法2：

/*
  先序遍历：abdecfg
  中序遍历：dbeafcg
*/
#include
#include
#include

#define MaxArraySize 20

typedef struct BinTreeNode* BinTree;

struct BinTreeNode
{
	char element;
	BinTree leftchild;
	BinTree rightchild;
};

BinTree CreateTree_Pre(char* preOrder, char* midOrder, int n)
{
	BinTree tree = (BinTree)malloc(sizeof(struct BinTreeNode));
	if (!tree)
		return;
	tree->element = preOrder[0];
	tree->leftchild = NULL;
	tree->rightchild = NULL;
	if (n == 1)       //只剩下一个结点时，直接返回
		return tree;
	
	int  midPtr, leftLength, rightLength;
	midPtr = 0;
	while (midOrder[++midPtr] != preOrder[0])    //找出中序遍历中根节点的位置
		;
	leftLength = midPtr;        //左子树结点数
	rightLength = n - leftLength - 1;       //右子树结点数
	
	//偷懒起见，未创建新的数组
	tree->leftchild = CreateTree_Pre(&preOrder[1], midOrder, leftLength);     //注意左右子树在原数组中的位置
	tree->rightchild = CreateTree_Pre(&preOrder[leftLength + 1], &midOrder[leftLength + 1], rightLength);
	return tree;
}

void PrintPostOrder(BinTree t)  //打印后序遍历结果
{
	if (!t)
		return;
	PrintPostOrder(t->leftchild);
	PrintPostOrder(t->rightchild);
	printf("%c", t->element);
}

int main()
{
	BinTree t = (BinTree)malloc(sizeof(struct BinTreeNode));
	char pre[MaxArraySize], mid[MaxArraySize];
	printf("请输入先序遍历结果：");
	gets(pre);
	printf("请输入中序遍历结果：");
	gets(mid);
	printf("后序遍历结果为：");
	t = CreateTree_Pre(pre, mid, strlen(pre));
	PrintPostOrder(t);

	return 0;
}

8(存疑).

#include
#include
typedef struct BiTree{
	char data;
	struct BiTree *lchild;
	struct BiTree *rchild;
}BiTree;


typedef struct Squeue{
	BiTree data;
	struct BiTree *lchild;
	struct BiTree *rchild;
}Squeue;

bool isComplete(BiTree *T, Squeue *sq, int maxSize){
    if(!T){
        return true;
    }
    bool enQueue(Squeue *, BiTree *, int maxSize);
    bool deQueue(Squeue *, BiTree **, int maxSize);
    bool isEmpty(Squeue *);
    BiTree *p = T;
    BiTree *r = (BiTree *)malloc(sizeof(BiTree));  
    enQueue(sq, p, maxSize);   // 根节点入队
    while(!isEmpty(sq)){
        deQueue(sq, &r, maxSize);  // 取出队首元素
        if(r){
            enQueue(sq, r->lchild, maxSize);
            enQueue(sq, r->rchild, maxSize);
        }
        else{
            while(!isEmpty(sq)){    // 如果来到空结点，判断后续是否还有结点
                deQueue(sq, &r, maxSize);       // 取出队首元素
                if(r){
                    return true;
                }
            }
        }
    }
    return true;
}



int main(){
	int count = 0;
	bool isCom;
	BiTree *T = (BiTree *)malloc(sizeof(BiTree));
	Squeue *sq;

	BiTree *create(BiTree *);
	void nodeNum(BiTree *, int *);

	Squeue *createQueue(int);


	T = create(T);   // 创建二叉树
	nodeNum(T, &count);   // 统计二叉树结点数据
	sq = createQueue(count);  // 创建容量为二叉树结点个数大小的队列

	isCom = isComplete(T, sq, count);
	isCom ? printf("该二叉树是完全二叉树") : printf("该二叉树不是完全二叉树");
	return 0;
}