【算法】构造数组的MaxTree

构造数组的MaxTree

定义MaxTree：

• 数组没有重复元素
• 是二叉树
• 每一个子树上，值最大的节点是树的根节点

思路（即构造MaxTree的规则）：

• 一个节点的父节点是，数组中左边第一个比它大的数和右边第一个比它大的数中，较小的那个。
• 如果左边和右边都没有比他大的树，那么这个数是根节点

如数组{ 3, 4, 5, 1, 2}对应的MaxTree是：

        .
        5
       / \
      /   \
     4     2
    /     /
   /     /
  3      1

前序遍历如下

5
4
3
2
1

代码实现如下：

package com.lilydedbb;

import java.util.HashMap;
import java.util.Stack;

/**
 * Created by dbb on 2016/12/24.
 */
public class GetMaxTree {

    public static Node getMaxTree(int[] arr){

        Node[] nodeArr = new Node[arr.length];
        for(int i = 0; i < arr.length; i++){
            nodeArr[i] = new Node(arr[i]);
        }
        Stack<Node> stack = new Stack<Node>();
        HashMap<Node, Node> leftBigMap = new HashMap<Node, Node>();
        HashMap<Node, Node> rightBigMap = new HashMap<Node, Node>();

        // 创建leftBigMap
        for(int i = 0; i < arr.length; i++){
            Node curNode = nodeArr[i];
            while(!stack.isEmpty() && stack.peek().data < curNode.data){ // 让栈内节点始终是递减的，某节点左边第一个大于该节点的节点就是栈内前一个节点
                popStackSetMap(stack, leftBigMap);
            }
            stack.push(curNode);
        }
        while (!stack.isEmpty()){ // 把还未设置在hash表中的节点，设置在hash表中
            popStackSetMap(stack, leftBigMap);
        }

        // 创建rightBigMap
        for(int i = arr.length - 1; i >= 0; i--){
            Node curNode = nodeArr[i];
            while(!stack.isEmpty() && stack.peek().data < curNode.data){ // 让栈内节点始终是递减的，某节点右边边第一个大于该节点的节点就是栈内前一个节点
                popStackSetMap(stack, rightBigMap);
            }
            stack.push(curNode);
        }
        while (!stack.isEmpty()){ // 把还未设置在hash表中的节点，设置在hash表中
            popStackSetMap(stack, rightBigMap);
        }

        // 创建最大树
        Node head = null;
        for(int i = 0; i < arr.length; i++){
            Node curNode = nodeArr[i];
            Node left = leftBigMap.get(curNode); // 左边第一个大于自身的数
            Node right = rightBigMap.get(curNode); // 右边第一个大于自身的数
            if(left == null && right == null){
                head = curNode;
            }else if(left == null){
                // 如果右节点存在，就分配给右节点的左（右）子节点
                if(right.left == null)
                    right.left = curNode;
                else
                    right.right = curNode;
            }else if(right == null){
                // 如果左节点存在，就分配给左节点的左（右）子节点
                if(left.left == null)
                    left.left = curNode;
                else
                    left.right = curNode;
            }else{
                // parent为左右子节点中较小的一个
                Node parent = left.data < right.data ? left : right;
                if (parent.left == null)
                    parent.left = curNode;
                else
                    parent.right = curNode;
            }
        }

        return head;
    }

    public static void popStackSetMap(Stack<Node> stack, HashMap<Node, Node> map){
        // 弹出栈顶节点的同时，设定hash表，key为弹出的节点，value为新栈顶节点
        // 这样做的意义在于，弹出节点的左（右）边第一个大于自身的数就是新的栈顶节点
        // 之后就可以从hash表中以某节点为key，找到该节点左（右）边数第一个大于该节点的数
        Node node = stack.pop();
        if(stack.isEmpty()){
            map.put(node, null);
        }else{
            map.put(node, stack.peek());
        }
    }

}


class Node {

    public int data;
    public Node left;
    public Node right;

    public Node(int data) {
        this.data = data;
    }

    public static void preOrder(Node head){
        if(head == null)
            return;
        System.out.println(head.data);
        preOrder(head.left);
        preOrder(head.right);
    }
}