Lintcode-Max Tree

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 is

              6

            /    \

         5       3

       /        /   \

     2        0     1

 

 

Challenge

O(n) time complexity

Analysis:

Recursion: use recursion method, in the worst case, the complexity is O(n^2).

Linear method: Refer to the analysis of some other people: http://www.meetqun.com/thread-3335-1-1.html

這個題Leetcode上沒有，其實這種樹叫做笛卡樹（ Cartesian tree）。直接遞迴建樹的話複雜度最差會退化到O(n^2)。經典建樹方法，用到的是單調堆疊。我們堆疊裡存放的樹，只有左子樹，沒有有子樹，且根節點最大。
（1） 如果新來一個數，比堆疊頂的樹根的數小，則把這個數作為一個單獨的節點壓入堆疊。
（2） 否則，不斷從堆疊裡彈出樹，新彈出的樹以舊彈出的樹為右子樹，連線起來，直到目前堆疊頂的樹根的數大於新來的數。然後，彈出的那些數，已經形成了一個新的樹，這個樹作為新節點的左子樹，把這個新樹壓入堆疊。

這樣的堆疊是單調的，越靠近堆疊頂的數越小。
最後還要按照（2）的方法，把所有樹彈出來，每個舊樹作為新樹的右子樹。

Solution:

 

/**
 * 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) {
        if (A.length==0) return null;

        Stack<TreeNode> nodeStack = new Stack<TreeNode>();
        nodeStack.push(new TreeNode(A[0]));
        for (int i=1;i<A.length;i++)
            if (A[i]<=nodeStack.peek().val){
                TreeNode node = new TreeNode(A[i]);
                nodeStack.push(node);
            } else {
                TreeNode n1 = nodeStack.pop();
                while (!nodeStack.isEmpty() && nodeStack.peek().val < A[i]){
                    TreeNode n2 = nodeStack.pop();
                    n2.right = n1;
                    n1 = n2;
                }
                TreeNode node = new TreeNode(A[i]);
                node.left = n1;
                nodeStack.push(node);
            }
        

        TreeNode root = nodeStack.pop();
        while (!nodeStack.isEmpty()){
            nodeStack.peek().right = root;
            root = nodeStack.pop();
        }

        return root;

    
            
            

    }
}

 

Solution 2 (recursion):

/**
 * 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) {
        if (A.length==0) return null;

        TreeNode root = new TreeNode(A[0]);
        for (int i=1;i<A.length;i++)
            if (A[i]>root.val){
                TreeNode node = new TreeNode(A[i]);
                node.left = root;
                root = node;
            } else insertNode(root,null,A[i]);

        return root;
    }

    public void insertNode(TreeNode cur, TreeNode pre, int val){
        if (cur==null){
            TreeNode node = new TreeNode(val);
            pre.right = node;
            return;
        }

        if (cur.val<val){
            TreeNode node = new TreeNode(val);
            pre.right = node;
            node.left = cur;
            return;
        } else 
            insertNode(cur.right,cur,val);
    }

        
}