(LeetCode)108. 将有序数组转换为二叉搜索树 & 105. 从前序与中序遍历序列构造二叉树 & 106. 从中序与后序遍历序列构造二叉树

(LeetCode)108. 将有序数组转换为二叉搜索树

将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

示例:

给定有序数组: [-10,-3,0,5,9],

一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树：

      0
     / \
   -3   9
   /   /
 -10  5

 

二叉搜索树的中序遍历刚好可以输出一个升序数组。

所以题目给出的升序数组就是二叉搜索树的中序遍历。

根据中序遍历还原一颗树，又想到了 105 题 和 106 题，通过中序遍历加前序遍历或者中序遍历加后序遍历来还原一棵树。前序（后序）遍历的作用呢？提供根节点！然后根据根节点，就可以递归的生成左右子树。

这里的话怎么知道根节点呢？平衡二叉树，既然要做到平衡，我们只要把根节点选为数组的中点即可。

综上，和之前一样，找到了根节点，然后把数组一分为二，进入递归即可。注意这里的边界情况，包括左边界，不包括右边界。

 

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */  


public TreeNode sortedArrayToBST(int[] nums) {
    	    return sortedArrayToBST(nums, 0, nums.length);
    	}

    	private TreeNode sortedArrayToBST(int[] nums, int start, int end) {
    	    if (start == end) {
    	        return null;
    	    }
    	    int mid = (start + end) >>> 1;
    	    TreeNode root = new TreeNode(nums[mid]);
    	    root.left = sortedArrayToBST(nums, start, mid);
    	    root.right = sortedArrayToBST(nums, mid + 1, end);

    	    return root;
    	}
 

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

根据一棵树的前序遍历与中序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：

    3
   / \
  9  20
    /  \
   15   7

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal
 

如何遍历一棵树
有两种通用的遍历树的策略：

宽度优先搜索（BFS）

我们按照高度顺序一层一层的访问整棵树，高层次的节点将会比低层次的节点先被访问到。

深度优先搜索（DFS）

在这个策略中，我们采用深度作为优先级，以便从跟开始一直到达某个确定的叶子，然后再返回根到达另一个分支。

深度优先搜索策略又可以根据根节点、左孩子和右孩子的相对顺序被细分为前序遍历，中序遍历和后序遍历。

 

 class Solution {
	  // start from first preorder element
	  int pre_idx = 0;
	  int[] preorder;
	  int[] inorder;
	  HashMap<Integer, Integer> idx_map = new HashMap<Integer, Integer>();

	  public TreeNode helper(int in_left, int in_right) {
	    // if there is no elements to construct subtrees
	    if (in_left == in_right)
	      return null;

	    // pick up pre_idx element as a root
	    int root_val = preorder[pre_idx];
	    TreeNode root = new TreeNode(root_val);

	    // root splits inorder list
	    // into left and right subtrees
	    int index = idx_map.get(root_val);

	    // recursion 
	    pre_idx++;
	    // build left subtree
	    root.left = helper(in_left, index);
	    // build right subtree
	    root.right = helper(index + 1, in_right);
	    return root;
	  }

	  public TreeNode buildTree(int[] preorder, int[] inorder) {
	    this.preorder = preorder;
	    this.inorder = inorder;

	    // build a hashmap value -> its index
	    int idx = 0;
	    for (Integer val : inorder)
	    	idx_map.put(val, idx++);
	    return helper(0, inorder.length);
	  }
	}

 

106. 从中序与后序遍历序列构造二叉树
 

根据一棵树的中序遍历与后序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

例如，给出

中序遍历 inorder = [9,3,15,20,7]
后序遍历 postorder = [9,15,7,20,3]
返回如下的二叉树：

    3
   / \
  9  20
      /  \
   15   7

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal
 

class Solution {
	  // start from first preorder element
	  int pos_idx = 0;
	  int[] postorder;
	  int[] inorder;
	  HashMap<Integer, Integer> idx_map = new HashMap<Integer, Integer>();

	  public TreeNode helper(int in_left, int in_right) {
	    // if there is no elements to construct subtrees
	    if (in_left == in_right)
	      return null;

	    // pick up pre_idx element as a root
	    int root_val = postorder[pos_idx];
	    TreeNode root = new TreeNode(root_val);

	    // root splits inorder list
	    // into left and right subtrees
	    int index = idx_map.get(root_val);

	    // recursion 
	    pos_idx--;
	    // build left subtree
	    root.right = helper(index + 1, in_right);
	    root.left = helper(in_left, index);
	    // build right subtree
	    
	    return root;
	  }

	  public TreeNode buildTree(int[] inorder, int[] postorder) {
	    this.inorder = inorder;
	    this.postorder = postorder;
	    this.pos_idx = postorder.length-1;
	    // build a hashmap value -> its index
	    int idx = 0;
	    for (Integer val : inorder)
	    	idx_map.put(val, idx++);
	    return helper(0, inorder.length);
	  }
	}