LeetCode105. 从前序与中序遍历序列构造二叉树

根据一棵树的前序遍历与中序遍历构造二叉树。
注意:
你可以假设树中没有重复的元素。
例如，给出
前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：

   3
   / \
  9  20
    /  \
   15   7

思路1：

1 .前序遍历中第一个元素为根结点，中序中根节点左面全为左子树的结点，右面全为右子树的结点；
2. 因此拿前序数组中第一个元素在中序数组中寻找相同的元素，用top记录根结点在中序数组中的位置；
3. 用top值建立前序左右数组，中序左右数组，用来储存余下的结点；
4. 将左又子树的元素分别储存在新建的数组中（前序中序依次一一对应）；
5. 左右子树数组继续调用此方法；

代码1：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if (preorder.length == 0 || inorder.length == 0) {
			return null;
		}

		TreeNode result = new TreeNode(preorder[0]);
		if (preorder.length == 1) {
			return result;
		}

		int top = 0;
		for (top = 0; top < inorder.length; top++) {

			if (inorder[top] == preorder[0]) {
				break;
			}
		}
		int[] left_preorder = new int[top];
		int[] left_inorder = new int[top];
		int[] right_preorder = new int[preorder.length - top - 1];
		int[] right_inorder = new int[preorder.length - top - 1];

		for (int i = 0; i < top; i++) {
			left_preorder[i] = preorder[i + 1];
			left_inorder[i] = inorder[i];
		}
		
		result.left = buildTree(left_preorder, left_inorder);
		
		for (int i = 0; i < preorder.length - top - 1; i++) {
			right_preorder[i] = preorder[i + top + 1];
			right_inorder[i] = inorder[i + top + 1];
		}
		result.right = buildTree(right_preorder, right_inorder);
		return result;     
    }
}

思路2：

1. 同上，前序遍历中第一个元素为根结点，中序中根节点左面全为左子树的结点，右面全为右子树的结点；
2. 新建方法helper（int preStart, int inStart, int inEnd, int[] preorder, int[] inorder），参数分别为：前序开始的位置，中序开始的位置，结束的位置。
3. 因为，前序遍历中第一个元素为根节点，所以方法中创建节点root = new TreeNode(preorder[preStart]);
4. 最后分别遍历父亲节点的左右子树，当preStart > preorder.length - 1 || inStart > inEnd时，返回root；

代码2：

	public TreeNode buildTree(int[] preorder, int[] inorder) {
		return helper(0, 0, inorder.length - 1, preorder, inorder);
	}

	public TreeNode helper(int preStart, int inStart, int inEnd, int[] preorder, int[] inorder) {
		if (preStart > preorder.length - 1 || inStart > inEnd) {
			return null;
		}
		TreeNode root = new TreeNode(preorder[preStart]);
		int inIndex = 0;
		for (int i = inStart; i <= inEnd; i++) {
			if (inorder[i] == root.val) {
				inIndex = i;
			}
		}
		root.left = helper(preStart + 1, inStart, inIndex - 1, preorder, inorder);
		root.right = helper(preStart + inIndex - inStart + 1, inIndex + 1, inEnd, preorder, inorder);
		return root;
	}

思路3：

1. 同上，前序遍历中第一个元素为根结点，中序中根节点左面全为左子树的结点，右面全为右子树的结点；
2. 新建方法buildTree(int[] inorder, int inStart, int inEnd, int[] preorder, int preStart, int preEnd,HashMap<Integer, Integer> hm) ，参数意思同思路二；
3. 创建Hashmap，将中序的遍历的值存为键，将下标存为值；
4. 同二创建root = new TreeNode(preorder[preStart])，然后top = hm.get(preorder[preStart])，确定top的值top同思路1；
5. 4. 最后分别遍历父亲节点的左右子树，当preStart > preorder.length - 1 || inStart > inEnd时，返回root；

代码3：

public TreeNode buildTree(int[] inorder, int[] preorder) {
		if (inorder == null || preorder == null || inorder.length != preorder.length)
			return null;
		HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
		for (int i = 0; i < inorder.length; ++i)
			hm.put(inorder[i], i);
		return buildTree(inorder, 0, inorder.length - 1, preorder, 0, preorder.length - 1, hm);
	}

	private TreeNode buildTree(int[] inorder, int inStart, int inEnd, int[] preorder, int preStart, int preEnd,
			HashMap<Integer, Integer> hm) {
		if (preStart > preEnd || inStart > inEnd)
			return null;
		TreeNode root = new TreeNode(preorder[preStart]);
		int top = hm.get(preorder[preStart]);
		root.left = buildTree(inorder, inStart, top - 1, preorder, preStart + 1, top - 1, hm);
		root.right = buildTree(inorder, preStart + top - inStart + 1, inEnd, preorder, preStart + top - inStart + 1, inEnd, hm);
		return root;
	}