Max Tree

Question: 

Given an integer array with no duplicates. A max tree building on this array is defined as follow:

• The root is the maximum number in the array
• The left subtree and right subtree are the max trees of the subarray divided by the root number.

Construct the max tree by the given array.

 

Example:

Given [2, 5, 6, 0, 3, 1], the max tree constructed by this array is:

    6
   / \
  5   3
 /   / \
2   0   1

 

Analysis:

1. 递归：遍历找到最大值，然后对该最大值左半部分和右半部分分别调用递归函数。时间复杂度为O(nlogn)。

 

2. 递减stack（code见下）：解题思想几乎和Largest Rectangle in Histogram一模一样，区别就在与使用的是递减栈，而不是递增栈。通过递减栈，可以找到一个值它的左边第一个比它大的数，和右边第一个比它大的数。然后比较这两个数，较小的那个就是这个值的父节点的值（好像有点绕。。比方说有一个数组[1, 5, 2, 3, 4, ...]，对于数字3，它左边第一个比它大的数是5，右边第一个比它大的数是4，4比5小，所以节点3的父节点就是4，设TreeNode(4).left = TreeNode(3)）。

 

Code:

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */
public class Solution {
    /**
     * @param A: Given an integer array with no duplicates.
     * @return: The root of max tree.
     */
    public TreeNode maxTree(int[] A) {
        int size = A.length;
        if(A == null || size == 0) {
            return null;
        }
        
        Stack<TreeNode> stack = new Stack<TreeNode>();
        for(int i = 0; i <= size; i++) {
            TreeNode right = i == size ? new TreeNode(Integer.MAX_VALUE) 
                : new TreeNode(A[i]);
                
            while(!stack.isEmpty() && right.val > stack.peek().val) {
                TreeNode node = stack.pop();
                if(stack.isEmpty()) {
                    right.left = node;
                }else {
                    TreeNode left = stack.peek();
                    if(left.val > right.val) {
                        right.left = node;
                    }else {
                        left.right = node;
                    }
                }
            }
            
            stack.push(right);
        }
        
        return stack.peek().left;
    }
}

 

Complexity:

时间复杂度是O(n)。