二叉树的先序遍历、中序遍历、后序遍历 1、已知先序遍历、中序遍历求后序遍历 2、已知后序遍历、中序遍历求先序遍历

二叉树的先序遍历、中序遍历、后序遍历

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

typedef struct Node
{
	char data;
	struct Node* lchild;
	struct Node* rchild;
}BNode, *BiTree;

void create_bitree(BiTree* Tree)
{
	char ch;
	scanf("%c", &ch);
	if (ch == '#')
	{
		*Tree = NULL;
	}
	else
	{
		*Tree = (BiTree)malloc(sizeof(BNode));
		if (*Tree == NULL)
		{
			printf("memory malloc error");
			exit(-1);
		}
		(*Tree)->data = ch;
		create_bitree(&(*Tree)->lchild); //创建左子树
		create_bitree(&(*Tree)->rchild); //创建右子树
	}
}

void pre_order_traverse(BiTree Tree)
{
	if (Tree == NULL)
	{
		return;
	}
	else
	{
		printf("%c ", Tree->data);
		pre_order_traverse(Tree->lchild);
		pre_order_traverse(Tree->rchild);
	}
}

void inorder_traverse(BiTree Tree)
{
	if (Tree == NULL)
	{
		return;
	}
	else
	{
		inorder_traverse(Tree->lchild);
		printf("%c ", Tree->data);
		inorder_traverse(Tree->rchild);
	}
}

void post_order_traverse(BiTree Tree)
{
	if (Tree == NULL)
	{
		return;
	}
	else
	{
		post_order_traverse(Tree->lchild);
		post_order_traverse(Tree->rchild);
		printf("%c ", Tree->data);
	}
}

int main()
{
	char ch;
	BiTree Tree = NULL;
	create_bitree(&Tree); //先序遍历创建树
	printf("先序遍历:");
	pre_order_traverse(Tree);
	printf("\n");
	printf("中序遍历:");
	inorder_traverse(Tree);
	printf("\n");
	printf("后序遍历:");
	post_order_traverse(Tree);
	printf("\n");
	return 0;
}

已知先序遍历、中序遍历求后序遍历

输入
两个字符串，其长度n均小于等于26。
第一行为前序遍历，第二行为中序遍历。
二叉树中的结点名称以大写字母表示：A，B，C…最多26个结点。

输出
输入样例可能有多组，对于每组测试样例，
输出一行，为后序遍历的字符串。

样例输入
ABC
CBA
ABCDEFG
DCBAEFG
样例输出
CBA
DCBGFEA

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef struct Node
{
	char data;
	struct Node* lchild;
	struct Node* rchild;
}BiNode, *PBTree;

char pre_arry[28];
char in_arry[28];

PBTree create_tree(int L1, int R1, int L2, int R2)  //L1为先序遍历数组的左端点，R1为先序遍历数组的右端点    L2为中序遍历数组的左端点，R2为中序遍历数组的右端点
{
	if (L1 > R1)
	{
		return NULL;
	}
	PBTree root = (PBTree)malloc(sizeof(BiNode));
	if (!root)
	{
		printf("memory error");
		exit(-1);
	}
	root->data = pre_arry[L1];
	int p = 0;
	while (in_arry[p] != root->data) //找到中序数组中的位置,从前往后找
	{
		p++;
	}
	int len = p - L2;
	root->lchild = create_tree(L1+1, L1+len, L2, p-1); //先创建左子树，再创建右子树
	root->rchild = create_tree(L1+len+1, R1, p+1, R2);
	return root;
}

void post_order(PBTree Tree)
{
	if (Tree != NULL)
	{
		post_order(Tree->lchild);
		post_order(Tree->rchild);
		printf("%c", Tree->data);
	}
}

int main()
{
	memset(pre_arry, 0, sizeof(pre_arry));
	memset(in_arry, 0, sizeof(in_arry));
	while (gets_s(pre_arry))
	{
		int len = strlen(pre_arry);
		gets_s(in_arry);
		PBTree Tree = NULL;
		Tree = create_tree(0, len - 1, 0, len - 1);
		post_order(Tree);
		printf("\n");
	}
	return 0;
}

已知后序、中序求先序
样例输入：
CBDAEF
CDBFEA
样例输出：
FDCBEA

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef struct Node
{
	char data;
	struct Node* lchild;
	struct Node* rchild;
}BiNode, * PBTree;

char post_arry[28];
char in_arry[28];

PBTree create_tree(int L1, int R1, int L2, int R2)  //L1为后序遍历数组的左端点，R1为后序遍历数组的右端点    L2为中序遍历数组的左端点，R2为中序遍历数组的右端点
{
	if (L1 > R1)
	{
		return NULL;
	}

	PBTree root = (PBTree)malloc(sizeof(BiNode));
	if (!root)
	{
		printf("memory error");
		exit(-1);
	}
	root->data = post_arry[R1];
	int p = strlen(post_arry);
	while (in_arry[p] != root->data) //找到中序数组中的位置（从后往前找）
	{
		p--;
	}
	int len = R2 - p; //计算右子树有多少个结点
	root->rchild = create_tree(R1-len, R1-1, p + 1, R2);  //先创建右子树再创建左子树
	root->lchild = create_tree(L1, R1 - len - 1, L2, p-1);
	return root;
}

void pre_order(PBTree Tree)
{
	if (Tree != NULL)
	{
		printf("%c", Tree->data);
		pre_order(Tree->lchild);
		pre_order(Tree->rchild);

	}
}

int main()
{
	memset(post_arry, 0, sizeof(post_arry));
	memset(in_arry, 0, sizeof(in_arry));
	while (gets_s(post_arry))
	{
		int len = strlen(post_arry);
		gets_s(in_arry);
		PBTree Tree = NULL;
		Tree = create_tree(0, len - 1, 0, len - 1);
		pre_order(Tree);
		printf("\n");
	}
	return 0;
}