算法-双指针

算法-双指针

一、双指针

双指针指的是在遍历对象的过程中，不是普通的使用单个指针进行访问，而是使用两个相同方向（快慢指针）或者相反方向（对撞指针）的指针进行扫描，从而达到相应的目的。

为什么要使用双指针呢？

因为很多问题通过多个指针访问可以降低时间复杂度。一个恰当的算法可以降低程序运行时间；对于数据的维护，一般会根据数据的特点使用对应的数据结构进行维护。这也是为什么程序 = 算法 + 数据结构。

那么在什么样的问题上应当先想到双指针呢？

在处理双指针的问题上，关键是先通过问题要求找出双指针的移动策略（类似于临界条件）。比如快指针移动几步，对应着慢指针才移动，也就是满足什么条件下慢指针才移动。在处理有序问题上，应当首先想到双指针。在处理无序问题上，我们大多时候较难找到双指针的移动策略，所以可以先将无序问题转化为有序问题，再利用双指针进行处理。

二、2sum

class Solution {
    public int[] twoSum(int[] nums, int target) {
        if (nums == null || nums.length == 0) {
            return null;
        }
        //先将无序问题转化为有序问题
        Arrays.sort(numbers);
        
        int[] result = {-1, -1};
        int start = 0;
        int end = nums.length - 1;
        while (start < end) {
            if (nums[start] + nums[end] < target) {
                start++;
            } else if (nums[start] + nums[end] > target) {
                end--;
            } else {
                result[0] = start + 1;
                result[1] = end + 1;
                break;
            }
        }
        return result;
    }
}

三、3sum

class Solution {
    public List<List<Integer>> threeSum(int[] numbers) {
    	List<List<Integer>> result = new ArrayList<List<Integer>>();
        if (numbers == null || numbers.length == 0) {   
            return result;
        }
        //nlog(n)，先将无序问题转化为有序问题
        Arrays.sort(numbers);
        int len = numbers.length;
        for (int i = 0; i < len - 2; i++) {
            if (i > 0 && numbers[i] == numbers[i - 1]) {
                continue;
            }
            int left = i + 1;
            int right = len - 1;
            while(left < right) {
                if (numbers[i] + numbers[left] + numbers[right] == 0) {
                    List<Integer> list = new ArrayList<Integer>();
                    list.add(numbers[i]);
                    list.add(numbers[left]);
                    list.add(numbers[right]);
                    left++;
                    right--;
                    result.add(list);
                    while (left < right && numbers[left] == numbers[left - 1]) {
                        left++;
                    }
                    while (left < right && numbers[right] == numbers[right + 1]) {
                        right--;
                    }
                } else if (numbers[i] + numbers[left] + numbers[right] > 0) {
                    right--;
                } else {
                    left++;
                }
            }
        }
        return result;
    }
}

四、验证三角形

关键：两边之和大于第三边

class Solution {
    public int triangleNumber(int[] nums) {
        if (nums == null || nums.length < 3) {
            return 0;
        }
        Arrays.sort(nums);
        int total = 0;
        for (int k = S.length - 1; k >= 2; k--) {
            int start = 0;
            int end = k - 1;
            while (Start < end) {
                if (nums[start] + nums[end] > nums[k]) {
                    total += (end - start);
                    end --;
                } else {
                    start++;
                }
            }
        }
        return total;
    }
}

五、存水问题

class Solution {
public int trap(int[] height) {
    	if(height == null || height.length == 0) {
            return 0;
        }
        int length = height.length;
        int left = 0;
        int right = length - 1;
        int leftHeight = height[left];
        int rightHeight = height[right];
        int sum = 0;
        while (left < right) {
            if (leftHeight < rightHeight) {
                if (leftHeight > height[left + 1]) {
                    sum += leftHeight - height[left + 1];
                } else {
                    leftHeight = height[left +1];
                }
                left++;
            } else {
                if (rightHeight > height[right - 1]) {
                    sum += rightHeight - height[right - 1];
                } else {
                    rightHeight = height[right - 1];
                }
                right--;
            }
        }
        return sum;
    }
}