3.28---双指针法及单调栈拓展

 一、最长连续序列

class Solution {
    public int longestConsecutive(int[] nums) {
        if(nums.length == 0) return 0;
        Map<Integer,Integer> map = new HashMap<>();
        int max = 0;
        ArrayList<Integer> list = new ArrayList<>();
        Arrays.sort(nums);
        for(int i=0;i<nums.length;i++) {
            int val = 0;
            if(map.containsKey(nums[i])) continue;
            else{
                if(map.containsKey(nums[i]-1)) {
                    map.put(nums[i],1);
                    max++;
                }else{
                    list.add(max);
                    max = 0;
                    map.put(nums[i],0);
                }
            }
        }
        list.add(max);
        return Collections.max(list)+1;
    }
}

主体思路：先将这个数组排序，这样方便后续操作，然后用一个 map来存储信息，当键名为数组元素，对应的值有0和1，0表示该元素没有比它小的上一个元素，1表示有；判断思路是，先判断map中是否有和它重复的元素，重复则直接到下一次循环，不存储重复元素；如果没有重复元素，就判断它是否有比它小1的元素，如果有说明连续，就将值设置为1，并max作为计数器开始记录连续次数，如果没有比它小1的连续元素，说明连续断了，将其值设置为0表示不连续，然后将之前没断的max值赋值给list存储，重新清空max用于下一次连续的计数。最后只需要找出list中最大的数字返回即可。

二、移动零

class Solution {
    public void moveZeroes(int[] nums) {
       int index = 0;
       int temp = 0;
       for(int i=0;i<nums.length;i++){
          if(nums[i] != 0){
            temp = nums[i];
            nums[i] = 0;
            nums[index++] = temp;
          }
       }
    }
}

主体思路：只需要将不为0的数字排序好，之后数字全部为0即可。所以用Index来记录不为0的数字个数。

三、盛最多水的容器 

其实题目意思就是两个柱子的间距乘以左右两边柱子的最短高度的面积哪个最大？

主要解题思路，这道题明显用双指针法，一个从左往右，一个从右往左扫比较方便。哪个指针移动的判断条件是哪边短就移动哪边。

class Solution {
    public int maxArea(int[] height) {
     int left=0,right=height.length-1;
     int area=0,max = 0;
     while(left<right){
         area = Math.min(height[left],height[right])*(right-left);
         max = Math.max(max,area);
         if(height[left]<height[right]){
             left++;
         }else right--;
     }
        return max;
    }
}

四、接雨水

一开始我的思路是利用双指针，判断只要右边大于左边就说明有积水，然后利用两个指针的位置关系计算积水面积，但是按照上述例子，左指针在3的位置时，就没有指针比它还要大了；于是我换了一种思路，因为积水是对称的，所以我想通过上升下降趋势（上升的数字等于下降的数字时相当于找到了积水的左右两边）来计算，但是后续判断条件太多导致类似于[4,2,3]这样的例子无法实现，因为它中间不是空的，是还有元素在。

力扣上的双指针思路是：

计算每一列的储水量。当要计算第i列的储水量时，找到它左边的最大高度和右边的最大高度，然后比较左右高度哪个低，取较低的高度减去第i列的高度就是第i列的储水量。

那么如何找到左右两边的最大高度，一种简单的思路就是从I列分别向左右两边遍历数组，但是这样也很麻烦； 

还有一种新思路是从两边向中间寻找最大值。即左边初始化第一列作为左侧最大值lmax,右边初始化最后列作为右侧最大值rmax,然后再从第二列和倒数第二列开始比较最大值大小（最大值始终是比较完最大的那个数），如果左边lmax小于右边rmax，说明左边有积水可以算，那么第二列的积水量就等于lmax减去第二列的高度，然后往后移动进行下一次循环，但如果右边rmax小于左边lmax，那么倒数第二列的积水量就等于rmax减去倒数第二列的高度，然后往前移动进行下一次循环；直到左右两个指针相遇。

class Solution {
    public int trap(int[] height) {
        if (height.length <= 2) {
            return 0;
        }
        // 从两边向中间寻找最值
        int maxLeft = height[0], maxRight = height[height.length - 1];
        int l = 1, r = height.length - 2;
        int res = 0;
        while (l <= r) {
            // 不确定上一轮是左边移动还是右边移动，所以两边都需更新最值
            maxLeft = Math.max(maxLeft, height[l]);
            maxRight = Math.max(maxRight, height[r]);
            // 最值较小的一边所能装的水量已定，所以移动较小的一边。
            if (maxLeft < maxRight) {
                res += maxLeft - height[l ++];
            } else {
                res += maxRight - height[r --];
            }
        }
        return res;
    }
}

这道题还可以采用单调栈的思想。

单调栈： 

单调栈的应用背景：一维数组中要找出任一个元素的右边或者左边第一个比自己大或者小的元素的位置。

单调栈存储的是某个元素左边（或者右边，取决于循环是反方向还是正方向）第一个比自己大（或者小，取决于判断条件）的元素对应的索引下标。而且单调栈要么单调增（栈口小栈底大），要么单调减（栈口大栈底小）。

单调栈用的一些相关函数：

push函数：将（）内的元素放入队列（或栈）里，这时该元素的位置在队列的最后（或者栈的最顶部）。

peek()函数：返回索引为n-1的元素，即队列的最后一个元素（或栈最顶部的元素）

pop()函数：将索引为n-1的元素删除，即将栈顶元素弹出。

**************************************************************************************************************

这道题主要思路是，先定义一个栈顶元素（stack.push（0))，（这里用的是单调增栈，即小于栈口元素就放进栈）然后遍历数组进行比较，比较分为三种情况：

第一种情况：height[i]小于栈顶元素height[stack.peek()]，那么就stack.push(i)，把该索引放入栈内。

第二种情况：height[i]等于栈顶元素height[stack.peek()]，那就把当前栈口元素pop出去，然后把i放入栈内（相当于相等的话更新最靠右边的索引）。

第三种情况：height[i]大于栈顶元素height[stack.peek()]，说明我们找到了积水右边的边界，因为积水是对称的，所以我们取此时的栈口元素作为Mid,即积水在的位置，然后将mid从栈中弹出去，那么弹出去之后新的栈口元素就是积水的左边界，于是mid处积水就可以这样算：高等于左右边界较低的值减去height[mid],宽等于右边界索引减左边界索引-1，积水就等于高乘以宽。

class Solution {
    public int trap(int[] height) {
        int sum = 0;
        int lens = height.length;
        if(lens <2) return 0;
        Deque<Integer> stack = new LinkedList<>(); 
        stack.push(0);
        for(int i = 0; i < lens; i++){
            if(height[i] < height[stack.peek()]){
                stack.push(i);
            }else if(height[i] == height[stack.peek()]){
                stack.pop();
                stack.push(i);
            }else{
                 while((!stack.isEmpty() && height[i] > height[stack.peek()])){
                    int mid = stack.peek();
                    stack.pop();
                    if(stack.isEmpty()){//一定要注意这里的判断，否则如果Pop完栈内为空就会报错
                        break;
                    }
                    int h = Math.min(height[i],height[stack.peek()])-height[mid];
                    int w = i-stack.peek()-1;
                    sum+=h*w;
                }
            }
            stack.push(i);
        }
        return sum;
    }
}

五、单调栈拓展题目：每日温度

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        int lens = temperatures.length;
        int [] res = new int [lens];
        //定义栈，这里用LinkedList是因为方便增删
        Deque<Integer> stack = new LinkedList<>();
        stack.push(0);
        for(int i = 0;i < lens; i++){
            if(temperatures[i]<=temperatures[stack.peek()]){
                stack.push(i);
        //如果小于栈顶元素索引入栈
            }else{
                while(!stack.isEmpty() && temperatures[i]>temperatures[stack.peek()]){
                    res[stack.peek()] = i - stack.peek();
                    stack.pop();
        //如果大于栈顶元素说明找到目标元素，将目标元素索引i减去最开始比较的元素的索引（即栈顶元素）stack.peek()，得到两者之间距离，然后将当前栈内元素依次pop出，依次比较，直到栈空了，再把i作为新的栈顶元素
                }
                stack.push(i);
            }
        }
        return res;
    }
}

 简化版可以直接把if条件及里面的语句删除。

以上来源于力扣和代码随想录