刷题2：热题100

class Solution {
    public void moveZeroes(int[] nums) {
        int slow = 0;
        int fast = 0;
        while(fast<nums.length){
            if (nums[fast]==0){
                fast++;
                continue;
            }
            nums[slow] = nums[fast];
            slow++;
            fast++;
        }
        for (int i=slow;i<fast;i++) nums[i] = 0;
    }
}

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

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        for (int i=0;i<nums.length;i++){
            if (nums[0]>0) return result;
            if (i>0 && nums[i]==nums[i-1]) continue;
            int left=i+1;
            int right=nums.length-1;
            while(right>left){
                int sum = nums[i]+nums[left]+nums[right];
                if (sum>0){
                    right--;
                }else if (sum<0){
                    left++;
                }else{
                    result.add(Arrays.asList(nums[i], nums[left], nums[right]));
                    while(right>left && nums[left]==nums[left+1]) left++;
                    while(right>left && nums[right]==nums[right-1]) right--;
                    right--;
                    left++;
                }
            }
        }
        return result;
    }
}

class Solution {
    public int trap(int[] height) {
        int len = height.length;
        if (len<=2) return 0;
        int sum = 0;
        int[] maxleft = new int[len];
        int[] maxright = new int[len];
        maxleft[0] = height[0];
        for (int i=1;i<len;i++){
            maxleft[i] = Math.max(maxleft[i-1],height[i]);
        }
        maxright[len-1] = height[len-1];
        for(int i=len-2;i>=0;i--){
            maxright[i] = Math.max(maxright[i+1],height[i]);
        }
        for (int i=0;i<len;i++){
            int count = Math.min(maxleft[i],maxright[i]) - height[i];
            if (count>0) sum += count;
        }
        return sum;
    }
}

class Solution {
    public int trap(int[] height) {
        //单调栈方法
        int sum = 0;
        int len = height.length;
        Stack<Integer> st = new Stack<Integer>();
        st.push(0);
        for (int i=1;i<len;i++){
            if (height[i]<height[st.peek()]){
                st.push(i);
            }else if (height[i]==height[st.peek()]){
                st.pop();
                st.push(i);
            }else{
                while(!st.isEmpty() && height[i]>height[st.peek()]){
                    int mid = st.pop();
                    if (!st.isEmpty()){
                        int h = Math.min(height[i],height[st.peek()])-height[mid];
                        int w = i - st.peek() - 1;
                        int area = h*w;
                        if (area>0) sum += area;
                    }
                }
                st.push(i);
            }
        }
        return sum;
    }
}