--雙指標--

雙指標主要用於遍歷陣列，兩個指標指向不同的元素，從而協同完成任務。

通過雙指標可大大優化複雜度，減小因多重迴圈浪費的時間。

例題一：two-sum-ii-input-array-is-sort

題目描述：在有序陣列中找出兩個數，使它們的和為 target。

使用雙指標，一個指標指向值較小的元素，一個指標指向值較大的元素。指向較小元素的指標從頭向尾遍歷，指向較大元素的指標從尾向頭遍歷。

• 如果兩個指標指向元素的和 sum == target，那麼得到要求的結果；
• 如果 sum > target，移動較大的元素，使 sum 變小一些；
• 如果 sum < target，移動較小的元素，使 sum 變大一些。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        if (nums == null || nums.length == 0) {
            return new int[2];
        }
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int other = target - nums[i];
            if (map.containsKey(other)) {
                return new int[]{map.get(other), i};
            } else {
                map.put(nums[i], i);
            }
        }
        return new int[2];
    }
}
 

例題二：3sum

題目描述：給出一個數組，找出陣列中任意三個數字的和為0的所有組合情況，返回一個列表。

可利用上一題的思路，現將該陣列排序，先指定一個值，另外兩個值通過雙指標移動，找到解。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> res = new ArrayList<>();
        for (int i = 0; i < nums.length - 2; i++) {
            if (nums[i] > 0) { //最小值大於0，說明該陣列沒有負數，不可能有解
                break;
            }
            if (i != 0 && nums[i] == nums[i-1]) {
                continue;
            }
            int tmp = -nums[i];
            int lo = i + 1;
            int hi = nums.length - 1;
            while(lo < hi) {
                if (nums[lo] + nums[hi] < tmp) {
                    lo++;
                    while(hi > lo && nums[lo] == nums[lo - 1]) lo++;
                } else if (nums[lo] + nums[hi] > tmp) {
                    hi--;
                    while(hi > lo && nums[hi] == nums[hi + 1]) hi--;
                } else {
                    res.add(Arrays.asList(nums[i], nums[lo], nums[hi]));
                    lo++; hi--;
                    while(hi > lo && nums[lo] == nums[lo - 1]) lo++;
                    while(hi > lo && nums[hi] == nums[hi + 1]) hi--;
                }
            }
        }
        return res;
    }
}
 

例題三：4sum

題目描述：給出一個數組，找出任意四個數等於target的所有組合解，返回一個列表。

這時候，外部就要通過兩重迴圈指定兩個值，然後通過雙指標移動，找出解。

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> list = new ArrayList<List<Integer>>();
        if (nums == null || nums.length < 4)
            return list;
        Arrays.sort(nums);
        for (int i = 0; i < nums.length - 3; i++) {
            if(i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            for (int j = i + 1;j < nums.length - 2;j++) {
                if(j > i + 1 && nums[j] == nums[j - 1]) {
                    continue;
                }
                int low = j + 1, high = nums.length - 1;
                while (low < high) {
                    if(nums[i] + nums[j] + nums[low] + nums[high] == target) {
                        list.add(Arrays.asList(nums[i], nums[j], nums[low], nums[high]));
                        while(low < high && nums[low] == nums[low + 1]) low++;
                        while(low < high && nums[high] == nums[high - 1]) high--;
                        low++;
                        high--;
                    } else if (nums[i] + nums[j] + nums[low] + nums[high] < target) {
                        low++;
                    } else if(nums[i] + nums[j] + nums[low] + nums[high] > target) {
                        high--;
                    }
                }
            }
        }
        return list;
    }
}

例題四：sum-of-square-numbers

題目描述：給出一個數字，找出是否存在兩個數的平方和等於該數字，如果有返回true，否則返回false。

class Solution {
    public boolean judgeSquareSum(int c) {
        if (c < 0) {
            return false;
        }
        int i = 0, j = (int)Math.sqrt(c);
        while (i <= j) {
            int sum = i * i + j * j;
            if (sum == c) {
                return true;
            } else if (sum > c) {
                j--;
            } else if (sum < c) {
                i++;
            }
        }
        return false;
    }
}

雙指標的題型暫時總結到這裡，這種思想可以幫我們降低程式的複雜度，減少程式中的迴圈語句帶來的不必要的時間損耗。