算法--单调栈

解决问题示例：

//获得数组中任意一个元素的最近最小的元素，并将他以二维数组的方式存储下来
//arr[3, 4 ,3 ,2 ,3 ,4 ,1 ]
//    0  1  2  3  4  5  6
//结果存储方式： 0位置的3 0-->3 左边小于它且最近的没有，所以为-1,右边是3位置上的2 所以存储下来就是 [-1 , 3]
//第二个元素 1-->4 存储下来是 [0 , 2]
//所以整体返回的应该是一个二维数组 [ [-1 ,3] ,
//                                 [0 ,2] , ]

下面展示具体实现代码和测试代码：

//顺序栈测试
public class OrderStack {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] array = new int[5];
        for (int i = 0; i < array.length; i++) {
            System.out.println("请继续输入数组内容：");
            array[i] = sc.nextInt();
        }
        getNearLess(array);
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < 2; j++) {
                System.out.println(getNearLess(array)[i][j]+" ");

            }

        }

    }
    //顺序栈
    //获得数组中任意一个元素的最近最小的元素，并将他以二维数组的方式存储下来
    //arr[3, 4 ,3 ,2 ,3 ,4 ,1 ]
    //    0  1  2  3  4  5  6
    //结果存储方式： 0位置的3 0-->3 左边小于它且最近的没有，所以为-1,右边是3位置上的2 所以存储下来就是 [-1 , 3]
    //第二个元素 1-->4 存储下来是 [0 , 2]
    //所以整体返回的应该是一个二维数组 [ [-1 ,3] ,
    //                             [0 ,2] , ]
    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++) { //arr[i]进栈
            while (!stack.isEmpty() && arr[stack.peek().get(0)]>arr[i]){  //栈不为空且栈顶元素比将要入栈的元素大
                //这个时候，弹出栈顶元素，这个被弹出的元素的信息就有了，即：让它弹出的元素就是右边离他最近且比它小的元素，它压着的元素就是左边离他最近比它小的元素。
                List<Integer> popIs = stack.pop();
                int LeftLessIndex = stack.isEmpty() ? -1 : stack.peek().get(stack.peek().size()-1);//如果是栈底元素就是-1，否则就是它压着的元素
                for (Integer popi : popIs){
                    res[popi][0]=LeftLessIndex;
                    res[popi][1]=i;
                }
            }
            if (!stack.isEmpty() && arr[stack.peek().get(0)]==arr[i]){//将要入栈的等于栈顶元素，则加入到栈顶元素的列表中
                stack.peek().add(Integer.valueOf(i));
            }else {//否则就直接压入栈
                ArrayList<Integer> list = new ArrayList<>();
                list.add(i);
                stack.push(list);
            }
        }
        //数组都进过栈之后，开始结束的清算。从栈中逐次弹出剩余的元素,直到栈为空为止
        while (!stack.isEmpty()){
            List<Integer> popIs = stack.pop();
            int LeftLessIndex = stack.isEmpty() ? -1 : stack.peek().get(stack.peek().size()-1);
            for (Integer popi : popIs){
                res[popi][0] = LeftLessIndex;
                res[popi][1] = -1;
            }
        }
        return res;

    }
}

算法的思想就是，设计一个栈的数据结构，因为栈后进先出，这样的结构性质，所以可以采用“大数压小数”这样的方法使数组入栈。

每当将要入栈的元素发现栈顶元素的值比自己小，那这个元素就入栈，如果发现栈顶元素比自己大则弹出当前栈顶元素，并比较下一个栈顶元素，以此类推。

被弹出的元素是因为遇见了比自己小的进栈元素才弹出的，所以使得元素被弹出的进栈元素就是被弹出元素右边最近比它小的元素，而被弹出元素下放压着的元素就是左边最近比自己小的元素。

同样的道理，当数组全部入栈后，依次弹出元素的时候，也按上述方法去判断，最后栈底元素肯定是找不到左边最近比自己小的元素的那个元素。

自己的思考：

一个算法的设计思路应该是和数据结构相结合的，而一段程序就是算法和数据结构结合之后的产物。就像“栈”这个结构，当思考到递归这样的算法的时候，就不能忽视“栈”的性质了，因为递归是当函数调用不断发生进行下去的时候，达到递归的“归”的条件的时候，开始返回，这样的话就需要从最新入栈的方法进行返回弹出操作，如果这是一个队列的结构的话，就达不到这样的效果。