求元素左右较小值（单调栈）

求元素左右小于本身的值

问题重述：

给你一个整数数组 arr，求得每个元素左右小于其本身且距离它最近的元素，若不存在给定-1，返回所有位置的对应信息

示例 1：

输入：arr = [3, 4, 1, 3, 5, 2, 7]
输出：
-1 2
0 2
-1 -1
2 5
3 5
2 -1
5 -1
输入： repeatArr =  {3, 4, 1, 5, 3, 5, 2, 7}
输出：
-1 2
0 2
-1 -1
2 4
2 6
4 6
2 -1
6 -1

问题分析：

输入数组有两种可能，一种是不重复的数组，一种是重复的数组，我们只需要考虑重复数组即可，因为不重复的数组可以理解为是一种特殊的重复数组。为了便于理解单调栈的使用，我将这两种情况分别定义了一个方法。

对于不重复数组而言，我们可以使用一个栈，在每次添加元素进栈时将当前元素和栈顶元素进行比较，如果当前元素进栈破坏了栈的单调性，则弹出栈顶元素，重复进行比较，直到栈内元素满足单调性。我们弹出栈顶元素时，栈顶元素的下方元素就是他左边离他最近的比它小的元素，当前想要进栈的元素是右边离他最近的比他小的元素。（因为栈满足单调性，所以栈顶元素的下一个元素必定小于栈顶元素，又根据栈的先入后出特性，这个元素是距离栈顶元素最近的元素，将要压入的元素因为破坏了当前栈的单调性，也就是说，当前要加入的元素小于栈顶元素，因为是按照顺序从左到右进行遍历，所以该元素是距离栈顶元素最近的右边元素），遍历完数组所有元素后，将栈内剩余元素在进行弹出。

对于重复数组而言，原理与不重复数组基本相同，只是我们将所有重复的元素放在了一个列表内在存入数组。在弹出栈顶元素时，对列表进行遍历，列表每一个元素都进行判断。

解题方法：

单调栈

解题：

代码：

package cn.basic.algorithm;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/**
 * @author FOLDN
 * 单调栈结构
 */
public class DullStack {
    public static void main(String[] args) {
        int[] noRepeatArr = {3, 4, 1, 3, 5, 2, 7};
        int[] repeatArr = {3, 4, 1, 5, 3, 5, 2, 7};
        int[][] noRepeatNearLess = getNoRepeatNearLess(noRepeatArr);
        int[][] repeatNearLess = getRepeatNearLess(repeatArr);
        for (int i = 0; i < noRepeatNearLess.length; i++) {
            System.out.println(noRepeatNearLess[i][0] + " " + noRepeatNearLess[i][1]);
        }
        System.out.println("----------------");
        for (int i = 0; i < repeatNearLess.length; i++) {
            System.out.println(repeatNearLess[i][0] + " " + repeatNearLess[i][1]);
        }
    }

    public static int[][] getNoRepeatNearLess(int[] arr) {
        // 创建一个二维数组存放结果
        int[][] result = new int[arr.length][2];
        // 创建一个栈
        Stack<Integer> stack = new Stack<>();
        // 对数组arr进行循环
        for (int i = 0; i < arr.length; i++) {
            // 当单调栈不为空且栈顶元素大于当前元素时，将当前栈顶元素元素移除(如果用小于号那么就得到的时最大元素)
            while (!stack.isEmpty() && arr[stack.peek()] > arr[i]) {
                // 获得栈顶元素，这个元素是数组下标
                int index = stack.pop();
                // 此时判断栈是否为空，若为空的话，没有比它更小的值，那么左边加入-1
                if (stack.isEmpty()) {
                    result[index] = new int[]{-1, i};
                } else {
                    // 不为空则栈顶下面的下标对应的值就是左边的最小值对应的下标，当前i为右边最小值对应下标
                    result[index] = new int[]{stack.peek(), i};
                }
            }
            // 将当前下标加入栈
            stack.push(i);
        }
        // 剩余的元素都只有左边有最小值，右边都没有最小值，右边直接加入-1，原理同上
        while (!stack.isEmpty()) {
            int index = stack.pop();
            if (stack.isEmpty()) {
                result[index] = new int[]{-1, -1};
            } else {
                result[index] = new int[]{stack.peek(), -1};
            }
        }
        return result;
    }
    public static int[][] getRepeatNearLess(int[] arr) {
        // 创建一个二维数组存放结果
        int[][] result = 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> pop = stack.pop();
                // 对列表中的值进行遍历，当前的i为右边最小值，该列表下方列表中最后一个元素为左边最小值（因为压入顺序越后面的越近，如果改成选择最远的那么就取第一个元素）
                for (Integer index : pop) {
                    if (stack.isEmpty()){
                        // 当该列表下面没有元素时，代表当前值左边没有比它更小的值
                        result[index] = new int[]{-1,i};
                    }else {
                        result[index] = new int[]{stack.peek().get(stack.peek().size()-1),i};
                    }
                }
            }
            if (!stack.isEmpty() && arr[stack.peek().get(stack.peek().size()-1)] == arr[i]){
                // 当前值和列表中对应的数组值相同，将当前的i加入列表中
                stack.peek().add(i);
            } else {
                ArrayList<Integer> newList = new ArrayList<>();
                newList.add(i);
                stack.push(newList);
            }
        }
        while (!stack.isEmpty()){
            // 原理同上，只是右边的值只能是-1，因为筛选到了最后，每个值右边都没有比他更大的值了
            List<Integer> pop = stack.pop();
            for (Integer index : pop) {
                if (stack.isEmpty()){
                    result[index] = new int[]{-1,-1};
                }else {
                    result[index] = new int[]{stack.peek().get(stack.peek().size()-1),-1};
                }
            }
        }
        return result;
    }
}

代码解析：

重复数组与不重复数组原理基本一致，这里只讲述重复数组

创建一个存放列表的栈，用来存放数组下标。对数组元素进行循环，每一个元素循环之前，先进行条件判断，只有不影响栈的单调性的元素才能加入栈，如果破坏了栈的单调性，那就弹出栈顶元素，弹出栈顶元素时，要对栈顶元素（列表）进行遍历，对其中每一个值进行条件判断，然后得出对应的左右信息，若栈为空，左端则没有比其更小的元素，左边为-1，右边为当前要加入的下标，若栈不为空，栈顶元素的下一个元素（列表）的最后一个值就是栈顶列表中当前值的左边最近值（因为栈是先入后出），右边同样为当前要加入的下标，直到满足条件再加入。加入栈中时要进行判断，判断当前栈顶列表中的元素对应的数组值和当前数组值是否相同，若相同，则把当前下标加入栈顶列表中，否则创建一个新的列表加入栈中。最后弹出栈中剩余的元素。

总结：

单调栈：栈内元素按照规则排序，如果压入的元素不符合规则，则弹出队尾元素，直到满足规则。（只能操作栈顶）