leecode 解题总结：105. Construct Binary Tree from Preorder and Inorder Traversal

#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
/*
问题:
Given preorder and inorder traversal of a tree, construct the binary tree.

Note:
You may assume that duplicates do not exist in the tree.
分析：这是根据前序和中序构建二叉树。默认不存在重复的元素。
前序的特点是根节点在前面
中序的特点左根右
1】可以每次先寻找前序中从后向前的根节点root，然后在中序中找到该根节点将根节点划分成左子树和右子树
2】然后寻找下一个根节点，重复1的步骤
假设前序为A[1...n],中序为B[1...n]。那么当前根节点为A的第i个结点
i=1,寻找到B中j的位置对应结点为根节点，则有B[1..j-1],B[j+1...n]
    注意找到根节点划分后，中序对应左子树的根节点范围在
	A[2...j]，右子树的根节点范围在A[j+1...n]
i=2,寻找到B中k的位置对应新的根节点，假设1<=k <= j-1,则将B[1...j-1]继续划分为
    B[1...k-1],B[k+1..j-1]

	当出现B[p...q]时，且p=q,说明此时划分后只有一个结点，后续无需再划分，并根据B[p]来构建一个结点
	并返回，
	

举例：给定一个前序是
        5
	  4     7
     2    6    9
    1 3       8
前序是:5 4 2 1 3 7 6 9 8
中序是:1 2 3 4 5 6 7 8 9
后序是:1 3 2 4 6 8 9 7 5

输入:
9(元素个数)
5 4 2 1 3 7 6 9 8(前序)
1 2 3 4 5 6 7 8 9(中序)
输出:
1 3 2 4 6 8 9 7 5(后序)

关键:
1
1】可以每次先寻找前序中从后向前的根节点root，然后在中序中找到该根节点将根节点划分成左子树和右子树
2】然后寻找下一个根节点，重复1的步骤
假设前序为A[1...n],中序为B[1...n]。那么当前根节点为A的第i个结点
i=1,寻找到B中j的位置对应结点为根节点，则有B[1..j-1],B[j+1...n]
    注意找到根节点划分后，中序对应左子树的根节点范围在
	A[2...j]，右子树的根节点范围在A[j+1...n]
i=2,寻找到B中k的位置对应新的根节点，假设1<=k <= j-1,则将B[1...j-1]继续划分为
    B[1...k-1],B[k+1..j-1]

	当出现B[p...q]时，且p=q,说明此时划分后只有一个结点，后续无需再划分，并根据B[p]来构建一个结点

2
//将中序划分成两部分
int leftLen = index - inBeg;
TreeNode* leftNode = dfs(preorder , preBeg + 1 , preBeg + leftLen , inorder , inBeg , index - 1 );
TreeNode* rightNode = dfs(preorder, preBeg + leftLen + 1 , preEnd , inorder , index + 1 , inEnd);
*/ 

struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution {
public:
	TreeNode* dfs(vector<int>& preorder, int preBeg , int preEnd, vector<int>& inorder , int inBeg , int inEnd)
	{
		if(preorder.empty() || inorder.empty() || (inBeg > inEnd) || (preBeg > preEnd) )
		{
			return NULL;
		}
		if(inBeg == inEnd)
		{
			TreeNode* node = new TreeNode(inorder.at(inBeg));
			return node;
		}
		//对结点进行划分，首先获取根节点的值
		int root = preorder.at(preBeg);
		//寻找根节点在中序中的位置
		int index = -1;
		for(int i = inBeg ; i <= inEnd ; i++)
		{
			if(root == inorder.at(i))
			{
				index = i;
				break;
			}
		}
		//如果没有寻找到根节点
		if(index == -1)
		{
			return NULL;
		}
		TreeNode* rootNode = new TreeNode(root);
		//将中序划分成两部分
		int leftLen = index - inBeg;
		TreeNode* leftNode = dfs(preorder , preBeg + 1 , preBeg + leftLen , inorder , inBeg , index - 1 );
		TreeNode* rightNode = dfs(preorder, preBeg + leftLen + 1 , preEnd , inorder , index + 1 , inEnd);
		if(leftNode)
		{
			rootNode->left = leftNode;
		}
		if(rightNode)
		{
			rootNode->right = rightNode;
		}
		return rootNode;
	}

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
		if(preorder.empty() || inorder.empty() || ( preorder.size() != inorder.size() ) )
		{
			return NULL;
		}
        TreeNode* root = dfs(preorder , 0 , preorder.size() - 1 , inorder , 0 , inorder.size() - 1);
		return root;
    }
};

void print(vector<int>& result)
{
	if(result.empty())
	{
		cout << "no result" << endl;
		return;
	}
	int size = result.size();
	for(int i = 0 ; i < size ; i++)
	{
		cout << result.at(i) << " " ;
	}
	cout << endl;
}

//后续遍历树
void nextorderVisit(TreeNode* root , vector<int>& result)
{
	if(!root)
	{
		return ;
	}
	nextorderVisit(root->left, result);
	nextorderVisit(root->right , result);
	if(root)
	{
		result.push_back(root->val);
	}
}

void deleteTree(TreeNode* root)
{
	if(!root)
	{
		return;
	}
	if(NULL == root->left && NULL == root->right)
	{
		delete(root);
		root = NULL;
	}
	if(root)
	{
		deleteTree(root->left);
		deleteTree(root->right);
	}
}

void process()
{
	 vector<int> preorder;
	 vector<int> inorder;
	 int value;
	 int num;
	 Solution solution;
	 vector<int> result;
	 while(cin >> num )
	 {
		 preorder.clear();
		 inorder.clear();
		 for(int i = 0 ; i < num ; i++)
		 {
			 cin >> value;
			 preorder.push_back(value);
		 }
		 for(int i = 0 ; i < num ; i++)
		 {
			 cin >> value;
			 inorder.push_back(value);
		 }
		 //接下来构建树
		 TreeNode* root = solution.buildTree(preorder , inorder);
		 nextorderVisit(root , result);
		 print(result);
		 deleteTree(root);
	 }
}

int main(int argc , char* argv[])
{
	process();
	getchar();
	return 0;
}