LeetCode第十七天栈之柱状图中最大的矩形84(多解：暴力+栈+哨兵）

本文链接：https://blog.csdn.net/ss977/article/details/110749212

在这里插入图片描述

暴力解法

从0开始遍历，每一次向两边扩散
记录当前可扩散的最大面积
返回遍历结束后最大面积

    public static int largestRectangleArea(int[] heights) {
        if (heights==null) return 0;
        int number,max=0;
        for (int i=0;i<heights.length;i++){
            number=1;
            for (int l=i+1;l<heights.length;l++){
                if (heights[l]>=heights[i])
                    number++;
                else break;
            }
            for (int r=i-1;r>=0;r--){
                if (heights[r]>=heights[i])
                    number++;
                else break;
            }
            max=Math.max(heights[i]*number,max);
        }

        return max;
    }

在这里插入图片描述

栈

public static int largestRectangleArea(int[] heights) {
        int len=heights.length;
        if (len==0) return 0;
        if (len==1) return heights[0];
        int area=0;
        Deque<Integer> stack=new ArrayDeque<>();
        for (int i=0;i<len;i++) {
            while (!stack.isEmpty()&&heights[stack.peekLast()]>heights[i]) {
                //记录栈底元素
                int height=heights[stack.removeLast()];
                //if栈为空
                int width;
                if (stack.isEmpty()) width=i;
                else width=i-stack.peekLast()-1;
                area=Math.max(area,width*height);
                /**第一次，栈里：2
                 * i：1
                 * h：2
                 * w:1（特殊情况）
                 * maxS：0
                 * 2 出栈
                 **/
                /**
                 * 第二次，栈里：1
                 * i: 2
                 */
                /**
                 * 第三次，栈里：5,1
                 * i：3
                 */
                /**
                 * 第四次,栈里：6，5，1
                 * i：4
                 * h：6
                 * w：4-2-1=1
                 * max:1*6
                 * 6 出栈
                 */
                /**
                 * 第五次,栈里：5，1
                 * i：4
                 * h：5
                 * w：4-1-1=2
                 * max:2*5
                 * 5 出栈
                 */
                /**
                 * 第六次,栈里：2，1
                 * i：5
                 */
                /**
                 * 第七次,栈里：3，2，1
                 * i：5
                 */
            }
            stack.addLast(i);
        }
        while (!stack.isEmpty()) {
            //记录栈底元素
            int height = heights[stack.removeLast()];
            //if栈为空
            int width;
            if (stack.isEmpty()) width = len;
            else width =len - stack.peekLast() - 1;
            area = Math.max(area, width * height);
            /**
             * 第八次,栈里：3，2，1
             * h：3
             * w：6-4-1=1
             * max：3*1
             * 3 出栈
             */
            /**
             * 第九次,栈里：2，1
             * h：2
             * w：6-1-1=4
             * max：2*4
             */
            /**
             * 第十次,栈里：1
             * h：1
             * w：6
             * max：1*6
             */
        }
        return area;
    }

在这里插入图片描述

栈+哨兵

使用【哨兵】（Sentinel）：可以避免特殊情况的讨论，例如栈为空的情况等等。
哨兵的其他应用：单链表虚拟头结点、插入排序。

    public static int largestRectangleArea(int[] heights) {
        int len=heights.length;
        if (len==0) return 0;
        if (len==1) return heights[0];
        int area=0;
        int[] newHeights=new int[len+2];
        for (int i=0;i<len;i++){
            newHeights[i+1]=heights[i];
        }
        len+=2;
        heights=newHeights;
        Deque<Integer> stack=new ArrayDeque<>();
        stack.addLast(0);
        for (int i=1;i<len;i++) {
            while (heights[stack.peekLast()]>heights[i]) {
                //记录栈底元素
                int height=heights[stack.removeLast()];
                int width=i-stack.peekLast()-1;
                area=Math.max(area,width*height);
            }
            stack.addLast(i);
        }
        return area;
    }