二叉树的创建

方法一：由扩展先序序列建立二叉树

#include <stdio.h>
#include <stdlib.h>
typedef struct TreeNode {
	char elem;
	struct TreeNode* ls; //左孩子
	struct TreeNode* rs; //右孩子
}tnode;

tnode* CreateTree()   //创建一颗二叉树 
{
	char elem;     
	tnode* newnode;  //申请指针
	elem = getchar(); //输入内容

	if (elem == '#')       //输入#代表空指针
	{
		newnode = NULL;
	}
	else   //采用先序遍历的顺序
	{
		newnode = (tnode*)malloc(sizeof(tnode));
		newnode->elem = elem;
		newnode->ls = CreateTree();
		newnode->rs = CreateTree();
	}

	return newnode;
}

void PrePrint(tnode* node)   //前序遍历
{
	if (node) {
		printf("%c", node->elem);
		PrePrint(node->ls);
		PrePrint(node->rs);
	}
}

void InPrint(tnode* node)  //中序遍历
{
	if (node) {
		InPrint(node->ls);
		printf("%c", node->elem);
		InPrint(node->rs);
	}
}

void PostPrint(tnode* node)   //后序遍历
{
	if (node) {
		PostPrint(node->ls);
		PostPrint(node->rs);
		printf("%c", node->elem);
	}
}


int main()
{
	tnode* head;
	head = CreateTree();
	PrePrint(head);
	printf("\n");
	InPrint(head);
	printf("\n");
	PostPrint(head);
	return 0;
}

方法二：由结点遍历序列恢复一颗二叉树

由先序和中序序列恢复一颗二叉树

1.先由先序序列中的第一个结点确定根节点D。

2.通过根节点D分割中序序列，分为左子树的中序序列和右子树的中序序列，同时获得左，右子树的结点个数。

3.根据左子树和右子树的结点个数来分割先序序列。

通过1,2,3部就可以确定上图中，左子树和右子树的先序序列和中序序列。

同理：

中序：左根右

后序：左右根

由中序和后序序列恢复一颗二叉树

 

 

 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

struct TreeNode* buildTree(int* preorder, int preorderSize, int* inorder, int inorderSize)  
{
	//传入四个参数，即分别传入前序遍历和后序遍历的结果数组

	if (preorderSize == 0 || inorderSize == 0)
		return NULL;

	struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
	int index; 

	//根节点永远为preorder的第一个

	root->val = preorder[0];

	//找到中序遍历中根节点的位置（index）

	for (index = 0; index < inorderSize; index++)
		if (inorder[index] == preorder[0])
			break;
	
	//使用递归分别把左子树和右子树传递进去
	root->left = buildTree(preorder + 1, index, inorder, index);
	root->right = buildTree(preorder + index + 1, preorderSize - index - 1, inorder + index + 1, preorderSize - index - 1);
	return root;
}

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */


struct TreeNode* buildTree(int* inorder, int inorderSize, int* postorder, int postorderSize){
    if(inorderSize==0||postorderSize==0)
        return NULL;
    int i;
    struct TreeNode * root = (struct TreeNode *)malloc(sizeof(struct TreeNode));
    root->val = postorder[postorderSize-1];
    for(i = 0;i<inorderSize;i++)
        if(inorder[i] == postorder[postorderSize-1])
            break;
    root->left = buildTree(inorder,i,postorder,i);
    root->right= buildTree(inorder+i+1,inorderSize-i-1,postorder+i,postorderSize-i-1);
    return root;
}