单调栈结构

单调栈
单调栈是一种特殊设计的栈结构,为了解决如下的问题:
给定一个可能含有重复数值的 arr[],i位置的数一定存在如下两种信息:

  1. arr[i]的左侧离 i 最近并且小于(或者大于)arr[i] 的数在哪?
  2. arr[i]的右侧离 i 最近并且小于(或者大于)arr[i] 的数在哪?

如果想要得到arr[]中所有元素的这两个位置的信息,怎么能让得到信息的过程尽可能的快?

单调栈的实现

无重复值
拿左右侧距离arr[i]最近并且小于arr[i]来举例
假设当前有数组arr[] = {3,1,5,7,2,6,4},从0 ~ N-1顺序遍历。而我们的单调栈严格保持着栈底到栈顶是由小到大的顺序,此时栈中为null,所以0位置的3直接放入栈中。
单调栈结构_第1张图片
下一个1位置1,如果此时将1放入栈中破坏了小 -> 大的栈结构,所以将0位置3弹出,弹出时收集0 - 3的左右侧距离最近的小于当前元素的信息。0 - 3弹出后栈中无元素,证明左侧没有比它小的,所以为 -1,右侧最近为1,此时弹出0->3 将 1-1放入栈中。
单调栈结构_第2张图片
继续向下,数组下标2位置的5和3位置的7都可以保证栈由小到大的顺序,所以按照顺序放入栈中即可。此时数组下标来到了4位置的2。
单调栈结构_第3张图片
4 - 2如果想要放入栈中,会破坏由小到大的顺序,所以此时弹出栈顶元素 3 - 7,3 - 7右侧最近并且小于当前元素的值为 4 - 2,左侧最近且小的元素为当前栈顶元素 2 - 5 ,3 - 7元素左右侧信息收集完成。
此时4 - 2依然不能放入栈中,因为当前栈顶元素为2 - 5,弹出栈顶元素2 - 5,收集 2 - 5 的信息,同样的,4 - 2元素过来导致的2 - 5元素出栈,所以 4 - 2 元素为2 - 5的右侧最近且小于当前元素的值。此时栈中剩余元素 1 - 1,所以2 - 5 右侧信息 4 - 2 左侧信息 1 -1。
栈中剩余元素 1 - 1,4 - 2放入满足条件,直接入栈。
单调栈结构_第4张图片
下一个元素 5 - 6直接入栈,来到最后一个元素 6 - 4。
单调栈结构_第5张图片
来看6 - 4,此时栈顶元素 5 - 6,直接入栈不符合有小到大要求,所以弹出栈顶元素 5 - 6,收集 5 - 6信息,6 - 4元素的到来导致的5 - 6元素的出栈,所以6 - 4为 5 - 6的右侧最近且小的元素,此时栈顶元素4 - 2为左侧最近且小的元素,收集好5 -6信息后,6 - 4元素入栈。
单调栈结构_第6张图片
此时数组已经遍历完了,接下来怎么办?循环弹出栈中元素,把栈弹空即可。
因为此时已经不会再有新的元素加进来,所以栈中剩余元素的右侧最近且小的值都为 - 1。
弹出 6 - 4后,栈顶元素为 4 - 2,所以 4 - 2是6 - 4左侧最近且小的元素,右侧为-1。
弹出 4 - 2后,栈顶元素为1 - 1,所以 1 - 1是 4 - 2左侧最近且小的元素,右侧为 -1。
最后剩的元素1 - 1,弹出后栈为null,所以1 - 1左右两侧都没有最近且小的值, -1 -1。
数组中所有元素左右侧信息收集完毕。
单调栈结构_第7张图片

证明(数组中无重复值)
我们来验证一下上面所说的流程,看它为什么是对的。
假设在某一步,B下面是A,此时由于C的到来B要出栈,此时要收集B的信息。

为什么C会是B右侧最近且小的数。

  1. C为什么会使B弹出? 由于我们单调栈的特性,所以一定是因为B的值大于C,并且是从数组0位置开始到 N - 1位置遍历,所以说数组中C一定在B的右边。
  2. B和C中间的数有没有可能小于B? 也不可能,如果BC中间有小于B的数,那B早就会被弹出栈,不会等C过来的时候才出栈。所以C才是B右边最近且小于B的数。

为什么B左边比它小的是A?

  1. 因为在栈中B在A的上面,所以在数组中B一定在A的右边。
  2. A和B中间的数,有没有可能小于A? 不可能,如果有这样的数,A早就会出栈,不会B下面压着A。
  3. A和B中间的数,有没有大于A 小于B? 也不可能,比如说A = 3 B = 7,在数组中是3 5 4 7这样的顺序。3进栈后5紧接着也会跟着进栈,但是到4的时候,5虽然出栈了,不过等7进栈时,B不会压着A,中间还会有个4,B能直接压着A说明AB中间没有 大于A小于B的数。
  4. A和B中间的数都是大于B的,B下面压着A,A在B的左边,那A不就是B左边最近且小的值么?
    单调栈结构_第8张图片

数组中有重复值
如果数组中有重复值该怎么弄? 栈中存一个链表结构,相同值的数组下标放在一起,来看下面的图。
假设数组int[] arr = {1,3,4,5,4,3,1,2},刚来上0 - 1时,栈中为null,直接入栈,后面的3 4 5同样符合栈中元素从小到大的顺序,一次入栈。此时来到了数组下标位置为4的元素。
单调栈结构_第9张图片
4 - 4小于当前栈顶元素 3 - 5,弹出栈顶元素,此时结算3 - 5元素的信息,因为是 4 - 4元素的到来导致我出栈的,所以我右侧最近且小的信息是4 - 4,左侧最近且小的元素为栈中下一个元素的链表中最后一个元素,在这里是2 - 4,所以3 - 5左侧最近且小的值2 - 4,右侧最近且小的值 4 - 4。还没完,此时栈顶元素2 - 4的值和4 - 4的值相等,统一放在链表中。
单调栈结构_第10张图片
接下往下走,来到了5 - 3,此时栈顶元素大于当前值5 - 3,弹出栈顶元素,2 - 4和4 - 4两个值一起结算,因为是5 - 3的到来导致我们两个出栈,所以右侧最近且小的值为5- 3,左侧最近且小的值,依然是找栈中下一个元素的链表中的最后一个元素,在这里是1 - 3,一起结算的相同值的左右最近且最小元素一定是一样的,所以2 - 4和4 - 4左侧最近且小的值为1 - 3,右侧近且小的值为5 - 3。弹出后,5 - 3压入栈中。
单调栈结构_第11张图片
在往下走,来到了6 - 1,同样处理,1 - 3 和 5 - 3 弹出,一起结算,左侧最近且小的值为 0 - 1,右侧最近且小的值为 6 - 1。6 - 1压入栈中。
单调栈结构_第12张图片
最后7 - 2直接入栈。数组遍历到头了,循环遍历直接弹出栈中元素。依然是没有新的元素加入,所以栈中剩余元素所有的右侧最近且小的值为-1。
7 - 2左侧最近且小的值,看栈中下一个元素的链表中最后一个元素,在这里为 6 - 1,所以 7 - 2的左侧最近且小的值为 6 - 1,右侧最近且小为 -1。
剩余的 0 - 1元素和 6 - 1元素,左右最近且小的值都为-1。
单调栈结构_第13张图片
数组中元素信息全部收集完成。

总结
那个元素使栈中元素弹出,即为弹出元素的右侧最近且小的值,弹出后的栈顶元素为弹出元素的左侧最近且小的值。数组长度为N,遍历完整个数组,所有元素再栈中最多进一次出一次,所以时间复杂度为 O ( N ) O(N) O(N)
如果数组中有重复值,则用链表维护相同值的元素下标。

代码
返回的二维数组中第一个数组代表arr中的下标,每个数组对应的第二个数组中一共两个值,0表示左侧最近且小,1表示右侧最近且小。
[
0 : [-1, 1]
1 : [-1, -1]
2 : [ 1, -1]
3 : [ 2, -1]
]
无重复值

 public static int[][] getNearLessNoRepeat(int[] arr) {
        int[][] result = new int[arr.length][2];

        Stack<Integer> stack = new Stack<>();
        for (int i = 0; i < arr.length; i++) {
            while (!stack.isEmpty() && arr[stack.peek()] > arr[i]) {
                Integer cur = stack.pop();
                Integer leftLessIndex = stack.isEmpty() ? -1 : stack.peek();
                result[cur][0] = leftLessIndex;
                result[cur][1] = i;
            }
            stack.push(i);
        }
        while (!stack.isEmpty()) {
            Integer cur = stack.pop();
            Integer leftLessIndex = stack.isEmpty() ? -1 : stack.peek();
            result[cur][0] = leftLessIndex;
            result[cur][1] = -1;
        }
        return result;
    }

有重复值

 public static int[][] getNearLess(int[] arr) {
        int[][] res = new int[arr.length][2];
        Stack<List<Integer>> stack = new Stack<>();

        for (int i = 0; i < arr.length; i++) {
            while (!stack.isEmpty() && arr[stack.peek().get(0)] > arr[i]) {
                List<Integer> linked = stack.pop();
                Integer leftLessIndex = stack.isEmpty() ? -1 : stack.peek().get(stack.peek().size() - 1);

                for (Integer cur : linked) {
                    res[cur][0] = leftLessIndex;
                    res[cur][1] = i;
                }
            }
            if (!stack.isEmpty() && stack.peek().get(0) == i) {
                stack.peek().add(Integer.valueOf(i));
            } else {
                ArrayList<Integer> list = new ArrayList<>();
                list.add(i);
                stack.push(list);
            }
        }

        while (!stack.isEmpty()) {
            List<Integer> lists = stack.pop();
            Integer leftLessIndex = stack.isEmpty() ? -1 : stack.peek().get(stack.peek().size() - 1);

            for (Integer cur : lists) {
                res[cur][0] = leftLessIndex;
                res[cur][1] = -1;
            }
        }
        return res;
    }

你可能感兴趣的:(算法,数据结构,java,算法,单调栈)