前序遍历和中序遍历树构造二叉树

代码1：

#include <iostream>
#include <vector>

using namespace std;


//Definition of TreeNode :
class TreeNode {
public:
	int val;
	TreeNode *left, *right;
	TreeNode(int val) {
		this->val = val;
		this->left = this->right = NULL;
	}
};



class Solution {

public:

	TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
		// write your code here
		if (preorder.size()<1 || inorder.size()<1)
		{
			return NULL;
		}

		return ConstructTree(preorder, inorder);

	}

	TreeNode* ConstructTree(vector<int>& preorder, vector<int>&inorder)
	{
		int len1 = preorder.size();
		int len2 = inorder.size();

		if (len1 == 0 || len2 == 0)
		{
			return NULL;
		}

		TreeNode* root = new TreeNode(preorder[0]);//根节点是前序的第一个元素
		if (len1 == 1 || len2 == 1)
		{
			return root;
		}

		int index = 0;
		int  i = 0;
		vector<int> lpreorder;
		vector<int> linorder;
		vector<int> rpreorder;
		vector<int> rinorder;

		for (i = 0; i < len2;i++)
		{
			if (inorder[i] == preorder[0])
			{
				index = i;
				break;
			}
		}

		for (i = 0; i < index;i++)
		{
			linorder.push_back(inorder[i]);
		}

		for (i = index + 1; i < len2;i++)
		{
			rinorder.push_back(inorder[i]);
		}

		for (i = 1; i <= index;i++)
		{
			lpreorder.push_back(preorder[i]);
		}

		for (i = index + 1; i < len2;i++)
		{
			rpreorder.push_back(preorder[i]);
		}

		root->left = ConstructTree(lpreorder, linorder);
		root->right = ConstructTree(rpreorder, rinorder);

		return root;
	}
	

	void Out(TreeNode* head)
	{
		if (NULL != head)
		{
			cout << head->val << " ";
			Out(head->left);
			Out(head->right);
		}
	}
};


int main()
{
	int pre[] = { 1, 2, 4, 7, 3, 5, 6, 8 };
	int in[] = { 4, 7, 2, 1, 5, 3, 8, 6 };
	int len = sizeof(pre) / sizeof(pre[0]);
	TreeNode* head = NULL;
	vector<int>preorder(pre, pre + len);
	vector<int>inorder(in, in + len);
	Solution s;
	head = s.buildTree(preorder, inorder);
	s.Out(head);
	return 0;
}

代码2：

#include<iostream>

using namespace std;


class TreeNode
{
public:
	int value;
	TreeNode* left;
	TreeNode* right;

	TreeNode(int val) :value(val), left(NULL), right(NULL){};
};

class Solution
{
public:
	void CresteTree(TreeNode* &root)
	{
		char ch = ' ';
		cin >> ch;

		if ('#' == ch)
		{
			root = NULL;
		}
		else
		{
			root = new TreeNode(atoi(&ch));
			CresteTree(root->left);
			CresteTree(root->right);
		}
	}

	
	//重建二叉树

	TreeNode* ConstructTree(int *preorder, int *inorder, int len)
	{
		if (NULL == preorder || NULL == inorder || len<=0)
		{
			return NULL;
		}

		return ConstructCore(preorder, preorder + len - 1, inorder, inorder + len - 1);
	}

	TreeNode* ConstructCore(int *startPreorder, int* endPreorder, int *startInorder, int *endInorder)
	{
		int rootValue = startPreorder[0];//根节点是前序的第一个元素
		TreeNode* root = new TreeNode(rootValue);
		root->left = root->right = NULL;

		if (startPreorder == endPreorder)
		{
			if (startInorder == endInorder && *startPreorder == *startInorder)//只有一个结点
			{
				return root;
			}
			else
			{
				throw exception("Invalid input");
			}
		}

		//在中序遍历中找到根节点
		int* rootInorder = startInorder;
		while (rootInorder <= endInorder && *rootInorder!=rootValue)
		{
			rootInorder++;
		}

		//没有找到这个结点
		if (rootInorder == endInorder && *rootInorder != rootValue)
		{
			throw exception("Invalid input");
		}

		int leftLength = rootInorder - startInorder;
		int* leftPreorder = startPreorder + leftLength;
		if (leftLength>0)
		{
			//构建左子树
			root->left = ConstructCore(startPreorder + 1, leftPreorder, startInorder, rootInorder - 1);
		}

		if (leftLength < endPreorder-startPreorder)//元素不全是左子树，构建右子树
		{
			root->right = ConstructCore(leftPreorder + 1, endPreorder, rootInorder + 1, endInorder);
		}

		return root;

	}

	void OutPerOrder(TreeNode *root)
	{
		if (NULL != root)
		{
			cout << root->value << " ";
			OutPerOrder(root->left);
			OutPerOrder(root->right);
		}
	}
};