LeetCode - Medium - 654. Maximum Binary Tree

Topic

• Tree

Description

https://leetcode.com/problems/maximum-binary-tree/

You are given an integer array nums with no duplicates. A maximum binary tree can be built recursively from nums using the following algorithm:

1. Create a root node whose value is the maximum value in nums.
2. Recursively build the left subtree on the subarray prefix to the left of the maximum value.
3. Recursively build the right subtree on the subarray suffix to the right of the maximum value.
   Return the maximum binary tree built from nums.

Example 1:

Input: nums = [3,2,1,6,0,5]
Output: [6,3,5,null,2,0,null,null,1]
Explanation: The recursive calls are as follow:
- The largest value in [3,2,1,6,0,5] is 6. Left prefix is [3,2,1] and right suffix is [0,5].
    - The largest value in [3,2,1] is 3. Left prefix is [] and right suffix is [2,1].
        - Empty array, so no child.
        - The largest value in [2,1] is 2. Left prefix is [] and right suffix is [1].
            - Empty array, so no child.
            - Only one element, so child is a node with value 1.
    - The largest value in [0,5] is 5. Left prefix is [0] and right suffix is [].
        - Only one element, so child is a node with value 0.
        - Empty array, so no child.

Example 2:

Input: nums = [3,2,1]
Output: [3,null,2,null,1]

Constraints:

• 1 <= nums.length <= 1000
• 0 <= nums[i] <= 1000
• All integers in nums are unique.

Analysis

方法一：用到后序遍历模式+暴力查找出最大值。

方法二：很巧妙的方法，类似用到中序遍历模式。link

另外，中序遍历这生成后的树，能得到输入那种序列。

Submission

import java.util.LinkedList;

import com.lun.util.BinaryTree.TreeNode;

public class MaximumBinaryTree {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
    	return constructMaximumBinaryTree(nums, 0, nums.length - 1);
    }
    
    private TreeNode constructMaximumBinaryTree(int[] nums, int start, int end) {
    	int maxValueIndex = findMax(nums, start, end);
    	if(maxValueIndex == -1) return null;
    	
    	return new TreeNode(nums[maxValueIndex], //
    			constructMaximumBinaryTree(nums, start, maxValueIndex - 1), //
    			constructMaximumBinaryTree(nums, maxValueIndex + 1, end));
    }
    
    private int findMax(int[] nums, int start, int end) {
    	if(start > end) return -1;
    	int maxValueIndex = start;
    	for(int i = start + 1; i <= end; i++) {
    		if(nums[i] > nums[maxValueIndex])
    			maxValueIndex = i;
    	}
    	return maxValueIndex;
    }
    
    public TreeNode constructMaximumBinaryTree2(int[] nums) {
    	LinkedList<TreeNode> stack = new LinkedList<>();
        for(int i = 0; i < nums.length; i++) {
            TreeNode curr = new TreeNode(nums[i]);
            while(!stack.isEmpty() && stack.peek().val < nums[i]) {
                curr.left = stack.pop();
            }
            if(!stack.isEmpty()) {
                stack.peek().right = curr;
            }
            stack.push(curr);
        }
        
        return stack.isEmpty() ? null : stack.removeLast();
    }
    
}

Test

import static org.junit.Assert.*;
import org.junit.Test;

import com.lun.util.BinaryTree;
import com.lun.util.BinaryTree.TreeNode;

public class MaximumBinaryTreeTest {

	@Test
	public void test() {
		MaximumBinaryTree obj = new MaximumBinaryTree();
		
		TreeNode actual1 = obj.constructMaximumBinaryTree(new int[] {3, 2, 1, 6, 0, 5});
		TreeNode expected1 = BinaryTree.integers2BinaryTree(6, 3, 5, null, 2, 0, null, null, 1);
		assertTrue(BinaryTree.equals(actual1, expected1));

		TreeNode actual2 = obj.constructMaximumBinaryTree(new int[] {3, 2, 1});
		TreeNode expected2 = BinaryTree.integers2BinaryTree(3, null, 2, null, 1);
		assertTrue(BinaryTree.equals(actual2, expected2));
	}
	
	@Test
	public void test2() {
		MaximumBinaryTree obj = new MaximumBinaryTree();
		
		TreeNode actual1 = obj.constructMaximumBinaryTree2(new int[] {3, 2, 1, 6, 0, 5});
		TreeNode expected1 = BinaryTree.integers2BinaryTree(6, 3, 5, null, 2, 0, null, null, 1);
		assertTrue(BinaryTree.equals(actual1, expected1));
		
		TreeNode actual2 = obj.constructMaximumBinaryTree2(new int[] {3, 2, 1});
		TreeNode expected2 = BinaryTree.integers2BinaryTree(3, null, 2, null, 1);
		assertTrue(BinaryTree.equals(actual2, expected2));
	}
}