LeetCode刷题系列（十五）Sums && Sort Colors

　　本篇包含关于2-sum、3-sum等关于给定和，求其中的数的题型，还有包含使用了3sum中前后指针的sort题型。

2 Sum

　　给定目标值，求数组中和为目标值的两个数。使用一个hash可以巧妙地将时间复杂度降到O(n)，之后的题可以参考此思路。

public int[] twoSum(int[] nums, int target) {
  Map<Integer, Integer> hash = new HashMap<Integer, Integer> ();
  int[] result = new int[2];
  for (int i = 0; i < nums.length; ++i) {
    if (hash.containsKey(target - nums[i])) {
      result[0] = hash.get(target - nums[i]) + 1;
      result[1] = i + 1;
      break;
    }
    hash.put(nums[i], i);
  }
  return result;
}

3 Sum

　　求数组中和为0的三个数。这道题在2Sum的基础上，在寻找第三个数时，使用left和right两个指针，类似于二分查找，可以有效减少算法时间。这种方法可以移植到接下来介绍的几道题上。

public ArrayList<ArrayList<Integer>> threeSum(int[] num) {

    ArrayList<ArrayList<Integer>> rst = new ArrayList<ArrayList<Integer>>();
    if(num == null || num.length < 3) {
        return rst;
    }
    Arrays.sort(num);
    for (int i = 0; i < num.length - 2; i++) {
        if (i != 0 && num[i] == num[i - 1]) {
            continue; // to skip duplicate numbers; e.g [0,0,0,0]
        }

        int left = i + 1;
        int right = num.length - 1;
        while (left < right) {
            int sum = num[left] + num[right] + num[i];
            if (sum == 0) {
                ArrayList<Integer> tmp = new ArrayList<Integer>();
                tmp.add(num[i]);
                tmp.add(num[left]);
                tmp.add(num[right]);
                rst.add(tmp);
                left++;
                right--;
                while (left < right && num[left] == num[left - 1]) { // to skip duplicates
                    left++;
                }
                while (left < right && num[right] == num[right + 1]) { // to skip duplicates
                    right--;
                }
            } else if (sum < 0) {
                left++;
            } else {
                right--;
            }
        }
    }
    return rst;
}

4 Sum

　　求数组中和为目标值的四个数。基本可以使用3sum的方法，在其基础上多加一个for循环（这个无可避免）。

public ArrayList<ArrayList<Integer>> fourSum(int[] num, int target) {
    ArrayList<ArrayList<Integer>> rst = new ArrayList<ArrayList<Integer>>();
    Arrays.sort(num);

    for (int i = 0; i < num.length - 3; i++) {
        if (i != 0 && num[i] == num[i - 1]) {
            continue;
        }

        for (int j = i + 1; j < num.length - 2; j++) {
            if (j != i + 1 && num[j] == num[j - 1])
                continue;

            int left = j + 1;
            int right = num.length - 1;
            while (left < right) {
                int sum = num[i] + num[j] + num[left] + num[right];
                if (sum < target) {
                    left++;
                } else if (sum > target) {
                    right--;
                } else {
                    ArrayList<Integer> tmp = new ArrayList<Integer>();
                    tmp.add(num[i]);
                    tmp.add(num[j]);
                    tmp.add(num[left]);
                    tmp.add(num[right]);
                    rst.add(tmp);
                    left++;
                    right--;
                    while (left < right && num[left] == num[left - 1]) {
                        left++;
                    }
                    while (left < right && num[right] == num[right + 1]) {
                        right--;
                    }
                }
            }
        }
    }

    return rst;
}

3 Sum Closest

　　求数组中和最接近目标值的3个数。这道题与3sum类似，使用其思路，将判别标准改变即可。

 public int threeSumClosest(int[] numbers, int target) {
    if (numbers == null || numbers.length < 3) {
        return -1;
    }

    Arrays.sort(numbers);
    int bestSum = numbers[0] + numbers[1] + numbers[2];
    for (int i = 0; i < numbers.length; i++) {
        int start = i + 1, end = numbers.length - 1;
        while (start < end) {
            int sum = numbers[i] + numbers[start] + numbers[end];
            if (Math.abs(target - sum) < Math.abs(target - bestSum)) {
                bestSum = sum;
            }
            if (sum < target) {
                start++;
            } else {
                end--;
            }
        }
    }

    return bestSum;
}

Sort Colors

　　将color号为0、1、2的数依次排序为0***1***2***。与3sum类似，使用两个指针，为1时不动，为0或3时进行交换即可。

 public void sortColors(int[] a) {
    if (a == null || a.length <= 1) {
        return;
    }

    int pl = 0;
    int pr = a.length - 1;
    int i = 0;
    while (i <= pr) {
        if (a[i] == 0) {
            swap(a, pl, i);
            pl++;
            i++;
        } else if(a[i] == 1) {
            i++;
        } else {
            swap(a, pr, i);
            pr--;
        }
    }
}

private void swap(int[] a, int i, int j) {
    int tmp = a[i];
    a[i] = a[j];
    a[j] = tmp;
}

Sort Colors II

　　这道题color号为从1到k。基于上题的思路，我们可以一次排序2个数，最前面（上题的0）和最后面（上题的2）的，其余看成上题的1，然后依次向中心收缩。

 public void sortColors2(int[] colors, int k) {
    int count = 0;
    int start = 0;
    int end = colors.length-1;
    while (count < k) {
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;

        for (int i = start; i <= end; i++) {
            min = Math.min(min, colors[i]);
            max = Math.max(max, colors[i]);
        }
        int left = start;
        int right = end;
        int cur = left;
        while(cur <= right) {
            if (colors[cur] == min) {
                swap(left, cur, colors);
                cur++;
                left++;
            } else if (colors[cur] > min && colors[cur] < max) {
                cur++;
            } else {
                int tmp = colors[cur];
                swap(cur, right, colors);
                right--;
            }
        }
        count += 2;
        start = left;
        end = right;
    }
}

void swap(int left, int right, int[] colors) {
    int tmp = colors[left];
    colors[left] = colors[right];
    colors[right] = tmp;
}

Sort Letters by Case

　　这道题也是使用前后指针然后交换的思路。

public void sortLetters(char[] chars) {
    int i = 0, j = chars.length - 1;
    char tmp ;
    while ( i <= j) {
        while (i <= j && Character.isLowerCase(chars[i]) ) i++;
        while (i <= j && Character.isUpperCase(chars[j]) ) j--;
        if (i <= j) {
            tmp = chars[i];
            chars[i] = chars[j];
            chars[j] = tmp;
            i++; j--;
        }
    }
    //write your code here
    return ;
}