我是方圆，无它，唯手熟尔

3. 无重复字符的最长子串（滑动窗口）

class Solution{
	public int lengthOfLongestSubstring(String s){
		int len = s.length();
		int ans = 0;
		//key用来存储具体的字符，value用来存储重复字符索引的下一位
		HashMap<Character,Integer> map = new HashMap<>();
		
		for(int start = 0,end = 0;end < len;end++){
			//判空
			if(len == 0)
				return 0;

			//正式开始
			if(map.containsKey(s.charAt(end)){
				//这里必须取最大值，避免start左移的情况
				//特殊例子，a..b..a..b 
				//假设start在第二个a处，直接map.get（b）的话，会左移
				start = Math.max(start,map.get(s.charAt(end)));
			}
			map.put(s.charAt(end),end + 1);
			ans = Math.max(ans,end - start);
		}	
		return ans;
	}
}

11. 盛最多水的容器（双指针）

class Solution{
	public int maxArea(int[] height){
		int ans = 0;
		int strat = 0;
		int end = height.length - 1;
	
		while(start < end){
			ans = Math.max(ans,(end - start)*Math.min(height[start],height[end]));

			if(height[start] < height[end]){
				start++;
			}else{
				end--;
			}
		}
		return ans;
	}
}

15. 三数之和（双指针）

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();
        int len = nums.length;
		
		//判空
        if(nums == null || len < 3) return ans;
		
		//排序，必须排序
        Arrays.sort(nums);
        for(int i = 0; i < len;i++){
            if(nums[i] > 0) break;
            
            if(i > 0 && nums[i] == nums[i - 1]) continue;
            
            int L = i + 1;
            int R = len - 1;
            while(L < R){
                int sum = nums[i] + nums[R] + nums[L];
                if(sum == 0){
                    ans.add(Arrays.asList(nums[i],nums[L],nums[R]));
                    while(L < R && nums[L] == nums[L + 1]) L++;
                    while(L < R && nums[R] == nums[R - 1]) R--;
                    L++;
                    R--;
                }else if(sum > 0){
                    R--;
                }else{
                    L++;
                }
            }
        }
        return ans;
    }
}

16. 最接近的三数之和（双指针）

class Solution {
    public int threeSumClosest(int[] nums, int target) {
    	//排序，双指针问题一般都要排序
    	//这样可以确定指针的移动条件
        Arrays.sort(nums);
        int len = nums.length;
        int ans = nums[0] + nums[1] + nums[2];

        for(int i = 0;i < len;i++){
            int L = i + 1;
            int R = len - 1;
            while(L < R){
                int sum = nums[i] + nums[L] + nums[R];
                
                if(Math.abs(sum - target) < Math.abs(ans - target)){
                    ans = sum;
                }
                if(sum > target){
                    R--;
                }else if(sum < target){
                    L++;
                }else{
                    return ans;
                }
            }
        }
        return ans;
    }
}

26. 删除排序数组中的重复项（双指针）

class Solution {
    public int removeDuplicates(int[] nums) {
        if(nums == null || nums.length == 0){
            return 0;
        }
		//最后p+1的值即为所求
        int p = 0;
        int q = 1;
        while(q < nums.length){
        	//当p和q所指的值不相等的时候，让p的下一个值等于q
        	//并且p指针后移一位
            if(nums[p] != nums[q]){
                nums[p+1] = nums[q];
                p++;
            }
            q++;
        }
        return p+1;
    }
}

121. 买卖股票的最佳时机

class Solution {
    public int maxProfit(int[] prices) {
    	
        int len = prices.length;
        //找出最低的股价
        int minPrice = Integer.MAX_VALUE;
        int ans = 0;

        for(int i = 0;i < len;i++){

            if(minPrice > prices[i]){
                minPrice = prices[i];
            }else if(minPrice < prices[i]){
                ans = Math.max(ans,prices[i] - minPrice);
            }
        }
        return ans;
    }
}

209. 长度最小的子数组（滑动窗口）

class Solution {
    public int minSubArrayLen(int s, int[] nums) {
        int left = 0;
        int sum = 0;
        int ans = Integer.MAX_VALUE;

        for(int right = 0;right < nums.length;right++){
            sum += nums[right];
            while(sum >= s){
                ans = Math.min(ans,right - left + 1);
                sum -= nums[left++];
            }
        }
        return ans == Integer.MAX_VALUE?0:ans;
    }
}