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;
}