经典结构 单调栈结构

内容：

1、原始问题

2、拓展题

 

 

 

1、原始问题

题目描述：

给你一个数组，找出数组中每个数左边离它近的比它大的数和右边离它近的比它大的数  要求算法时间复杂度为O(N)

解题思路：

使用一个栈，要求每次元素进栈后要维持栈中从栈底到栈顶元素值是从大到小排列的约定。将数组中的元素依次进栈，

如果某次元素进栈后会违反了上述的约定（即该进栈元素比栈顶元素大），就先弹出栈顶 元素，并记录该栈顶元素的信息：

• 该元素左边离它近的比它大的是该元素出栈后的栈顶元素，如果出栈后栈空，那么该元素左边没有比 它大的数
• 该元素右边离它近的比它大的是进栈元素

然后再尝试将进栈元素进栈，如果进栈后还会违反约定那就重复操作“弹出栈顶元素并记录该元素信息”，直到符合约定

或栈中元素全部弹出时再将该进栈元素进栈。当数组所有元素都进栈之后，栈势必不为空，弹出 栈顶元素并记录信息：

• 该元素右边没有比它大的数
• 该元素左边离它近的比它大的数是该元素从栈弹出后的栈顶元素，如果该元素弹出后栈为空，那么该 元素左边没有比它大的数

由于每个元素仅进栈一次、出栈一次，且出栈时能得到题目所求信息，因此时间复杂度为 O(N)

代码：

public class FindLeftAndRightBigger {
    // 记录每个数左边离它近的比它大的数和右边离它近的比它大的数的表
    public static HashMap<Integer, Integer> lBigMap = new HashMap<Integer, Integer>();
    public static HashMap<Integer, Integer> rBigMap = new HashMap<Integer, Integer>();

    private static void popStackSetLMap(Stack<Integer> stack,
            HashMap<Integer, Integer> map) {
        // 弹出栈中元素并记录最大信息(左边最大信息)
        int popElement = stack.pop();
        if (stack.isEmpty()) {
            map.put(popElement, null);
        } else {
            map.put(popElement, stack.peek());
        }
    }

    public static void findLeftAndRightBigger(int[] arr) {
        // 单调栈主逻辑
        Stack<Integer> stack = new Stack<Integer>();
        for (int i = 0; i < arr.length; i++) {
            // 遍历所有元素入栈 不符合入栈条件 弹出并记录信息
            while (!stack.isEmpty() && arr[stack.peek()] < arr[i]) {
                int top = stack.peek();
                popStackSetLMap(stack, lBigMap);     // 左边最大
                rBigMap.put(top, i);                 // 右边最大
            }
            stack.push(i);
        }
        while (!stack.isEmpty()) {
            // 所有元素已经入栈过  依次出栈并记录信息
            int top = stack.peek();
            popStackSetLMap(stack, lBigMap);         // 左边最大
            rBigMap.put(top, null);                 // 右边最大
        }
    }

    public static void printRes() {
        // 输出结果
        for (Entry<Integer, Integer> entry : lBigMap.entrySet()) {
            System.out.println("element: " + entry.getKey() + " - leftBigger:"
                    + entry.getValue());
        }
        for (Entry<Integer, Integer> entry : rBigMap.entrySet()) {
            System.out.println("element: " + entry.getKey() + " - rightBigger:"
                    + entry.getValue());
        }
    }

    // test
    public static void main(String[] args) {
        int[] arr = { 3, 4, 5, 1, 2 };
        findLeftAndRightBigger(arr);
        printRes();
    }
}

 

 

2、拓展题

(1)构造数组的MaxTree

题目描述：

给定一个没有重复元素的数组A，定义A上的MaxTree如下：

MaxTree的根节点为A中最大的数，根节点的左子树为数组中最大数左边部分的MaxTree，

右子树为数组中最大数右边部分的MaxTree。请根据给定的数组A，设计一个算法构造这个数组的MaxTree

思路：

一种思路是用堆做，把数组建成一个大根堆即可(O(N))

另外一种是用单调栈去做，使用一个栈底到栈顶单调递减的单调栈，将这些数 arr[] 依次入栈，

记录每个数左边离它近的比它 大的数，保存在 left[] 中（下标和 arr[] 一一对应），

记录每个数右边离它近的比它大的数，保存在 right[] 中

遍历 arr[] 建树：

• left[i] 和 right[i] 都不存在的，说明 arr[i] 是大的数，将其作为根节点；
• left[i] 和 right[i] 都存在则将arr[i]作为其中最小值节点的孩子节点，
• 只有一个存在（如 left[i] ）那就将 arr[i] 作为 left[i] 的孩子节点

这样建出的树必然是一颗二叉树，证明省略

代码：

public class MaxTree {
    public static class Node {
        public int value;
        public Node left;
        public Node right;

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

    private static void popStackSetMap(Stack<Node> stack,
            HashMap<Node, Node> map) {
        // 弹出栈中元素并记录最大信息
        Node popNode = stack.pop();
        if (stack.isEmpty()) {
            map.put(popNode, null);
        } else {
            map.put(popNode, stack.peek());
        }
    }
    
    private static void guaNode(Node child, Node parent){
        // 将child节点挂在parent节点下
        if (parent.left == null) {
            parent.left = child;
        } else {
            parent.right = child;
        }
    }

    public static Node getMaxTree(int[] arr) {
        // 初始化node
        Node[] nArr = new Node[arr.length];
        for (int i = 0; i < arr.length; i++) {
            nArr[i] = new Node(arr[i]);
        }
        // 记录信息的结构
        Stack<Node> stack = new Stack<Node>();
        HashMap<Node, Node> lBigMap = new HashMap<Node, Node>();
        HashMap<Node, Node> rBigMap = new HashMap<Node, Node>();
        // 单调栈结构(生成左最大和右最大)
        for (int i = 0; i < arr.length; i++) {
            Node cur = nArr[i];
            while (!stack.isEmpty() && stack.peek().value < cur.value) {
                popStackSetMap(stack, lBigMap);
            }
            // 节点入栈
            stack.push(cur);
        }
        while (!stack.isEmpty()) {
            popStackSetMap(stack, lBigMap);
        }
        for (int i = nArr.length - 1; i >= 0; i--) {
            Node cur = nArr[i];
            while (!stack.isEmpty() && stack.peek().value < cur.value) {
                popStackSetMap(stack, rBigMap);
            }
            // 节点入栈
            stack.push(cur);
        }
        while (!stack.isEmpty()) {
            popStackSetMap(stack, rBigMap);
        }
        // 遍历节点根据生成的左最大值表和右最大值表建树
        Node head = null;
        for (int i = 0; i < nArr.length; i++) {
            Node cur = nArr[i];
            Node left = lBigMap.get(cur);
            Node right = rBigMap.get(cur);
            if (left == null && right == null) {
                head = cur;
            } else if (left == null) {
                // 将cur挂在right下
                guaNode(cur, right);
            } else if (right == null) {
                // 将cur挂在left下
                guaNode(cur, left);
            } else {
                // 将cur挂在两端较小的节点上
                Node parent = left.value < right.value ? left : right;
                guaNode(cur, parent);
            }
        }

        return head;
    }
    
    // 打印二叉树的入口函数
    public static void printTree(Node head) {
        System.out.println("Binary Tree:");
        printInOrder(head, 0, "H", 17);
        System.out.println();
    }
    
    // 为节点加上左右两边的空格
    public static String getSpace(int num) {
        String space = " ";
        StringBuffer buf = new StringBuffer("");
        for (int i = 0; i < num; i++) {
            buf.append(space);
        }
        return buf.toString();
    }
    
    // 打印二叉树的主逻辑函数 
    public static void printInOrder(Node head, int height, String to, int len) {
        /*
         * head 头节点
         * height 当前高度
         * to 代表是左子树还是右子树 => 为H时代表根节点
         * len 代表每个节点最多占的宽度
         * */
        if (head == null) {
            return;
        }
        
        // 继续打印右子树
        printInOrder(head.right, height + 1, "v", len);
        
        String val = to + head.value + to;
        int lenM = val.length();            // 节点(加上节点标志)的长度
        int lenL = (len - lenM) / 2;        // 节点左边的长度
        int lenR = len - lenM - lenL;        // 节点右边的长度
        val = getSpace(lenL) + val + getSpace(lenR);        // 为节点加上左右两边的空格
        System.out.println(getSpace(height * len) + val);    // 打印当前节点
        
        // 继续打印左子树
        printInOrder(head.left, height + 1, "^", len);
    }

    public static void main(String[] args) {
        int[] arr = { 3, 4, 5, 1, 2 };
        Node head = getMaxTree(arr);
        printTree(head);
    }

}

 

(2)求最大子矩阵的大小

题目描述：

给定一个整型矩阵 map，其中的值只有 0 和 1 两种，求其中全是1的所有矩形区域中，最大的矩形区域为1的数量。

例如：

1　　1　　1　　0

其中，最大的矩形区域有 3 个 1，所以返回3。

再如：

1　　0　　1　　1

1　　1　　1　　1

1　　1　　1　　0

其中，最大的矩形区域有 6 个 1，所以返回6。

代码：

public class MaximalRectangle {
    // 将矩阵问题转换成数组求直方图最大面积问题求解
    public static int maxRecSize(int[][] map) {
        if (map == null || map.length == 0 || map[0].length == 0) {
            return 0;
        }
        int maxArea = 0;
        // TODO - 核心代码如下:
        int[] height = new int[map[0].length];
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[0].length; j++) {
                // 计算每一行中的值(上一个位置为0值为0否则值+1)
                height[j] = map[i][j] == 0 ? 0 : height[j] + 1;
            }
            maxArea = Math.max(maxRecFromBottom(height), maxArea);
        }

        return maxArea;
    }

    // height =》 [4, 3, 2, 5, 6] =》 直方图
    public static int maxRecFromBottom(int[] height) {
        // 计算直方图中最大的矩阵面积
        if (height == null || height.length == 0) {
            return 0;
        }
        int maxArea = 0;
        // TODO - 核心代码如下:
        Stack<Integer> stack = new Stack<Integer>();
        // 遍历入栈 出栈时扩范围
        for (int i = 0; i < height.length; i++) {
            while (!stack.isEmpty() && height[i] <= height[stack.peek()]) {
                // 此时i是右边界 k是左边界
                int j = stack.pop();
                int k = stack.isEmpty() ? -1 : stack.peek();
                int curArea = (i - k - 1) * height[j]; // 某个可以扩的最大范围大小
                maxArea = Math.max(maxArea, curArea);
            }
            stack.push(i);
        }
        // 都入栈了之后 遍历出栈并扩范围
        while (!stack.isEmpty()) {
            // 此时height.length是右边界(数组最右边) k是左边界
            int j = stack.pop();
            int k = stack.isEmpty() ? -1 : stack.peek();
            int curArea = (height.length - k - 1) * height[j];
            maxArea = Math.max(maxArea, curArea);
        }
        return maxArea;
    }

}