【二叉树1】根据前序和中序遍历建立一棵二叉树

【问题描述】已知两个序列，分别表示二叉树前序遍历和中序遍历的结果，根据他们建立一个二叉树，注意处理两个序列不合法的情况。

【举例】

如果输入为：

char preOrder[]={'a','b','d','e','c','f','g'};
char inOrder[]={'d','b','e','a','f','c','g'};

输出这样一棵树:

【代码】

#include "stdafx.h"
#include <iostream>
using namespace std;
struct BTreeNode{
	char value;
	struct BTreeNode *leftchild;
	struct BTreeNode *rightchild;
};
//notice:the forth param is refernce
void CreatBTree(char *preOrder,char *inOrder,int len,BTreeNode *&root){
	BTreeNode *temp=(BTreeNode*)malloc(sizeof(BTreeNode*));
	temp->value=*preOrder;
	temp->leftchild=NULL;
	temp->rightchild=NULL;

	if(root==NULL)
		root=temp;
	if(len==1)
		return;

	//record the end of inOrder'left part
	char *leftEnd=inOrder;
	//length of left part
	int leftLength=0;
	while(*leftEnd!=*preOrder)
	{
		++leftLength;
		//illegal
		if(leftLength>len)
			break;
		++leftEnd;
	}

	//length of right part
	int rightLength=len-leftLength-1;
	if(leftLength>0)
		CreatBTree(preOrder+1,inOrder,leftLength,root->leftchild);
	if(rightLength>0)
		CreatBTree(preOrder+leftLength+1,inOrder+leftLength+1,rightLength,root->rightchild);

}
int main(){
	char preOrder[]={'a','b','d','e','c','f','g'};
	char inOrder[]={'d','b','e','a','f','c','g'};
	int len=sizeof(preOrder)/sizeof(char);
	BTreeNode *root=NULL;
	CreatBTree(preOrder,inOrder,len,root);
	return 0;
}

【leetcode】假设两个序列是合法的，在leetcode上的函数接口不一样，我写的code如下所示，感觉很啰嗦的说……helper六个参数

TreeNode *helper(vector<int> &preorder, vector<int> &inorder, 
                        int pre_begin, int pre_end, int in_begin, int in_end){
        if (in_begin > in_end)
            return NULL;
        TreeNode *root = (TreeNode *) malloc(sizeof(TreeNode*));
        root->val = preorder[pre_begin];
          
        int root_pos = in_begin;
        int left_count = 0;
        while (inorder[root_pos] != root->val) {
            root_pos++;
            left_count++;
        }
    
        root->left = helper(preorder, inorder, pre_begin+1, pre_begin+left_count, 
                            in_begin, in_begin+left_count-1);
        root->right = helper(preorder, inorder, pre_begin+left_count+1, pre_end, 
                            in_begin+left_count+1, in_end);
        return root;
    }
    TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if (preorder.size() == 0)
            return NULL;
        return helper(preorder, inorder, 0, preorder.size()-1, 0, inorder.size()-1);
    }

【扩展】考虑用前序和后续遍历的序列建立一棵二叉树，还是上面的方法，改一下下标就ok

TreeNode *helper(vector<int> &postorder, vector<int> &inorder, 
                        int post_begin, int post_end, int in_begin, int in_end){
        if (in_begin > in_end)
            return NULL;
            
        TreeNode *root = (TreeNode *) malloc(sizeof(TreeNode*));
        root->val = postorder[post_end];
          
        int root_pos = in_begin;
        int left_count = 0;
        while (inorder[root_pos] != root->val) {
            root_pos++;
            left_count++;
        }
    
        root->left = helper(postorder, inorder, post_begin, post_begin+left_count-1, 
                            in_begin, in_begin+left_count-1);
        root->right = helper(postorder, inorder, post_begin+left_count, post_end-1, 
                            in_begin+left_count+1, in_end);
        return root;
    }
    TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if (postorder.size() == 0)
            return NULL;
        return helper(postorder, inorder, 0, postorder.size()-1, 0, inorder.size()-1);
    }