15. 3Sum

2024年2月20日 134次阅读

Given an array nums of n integers, are there elements a, b, c in nums such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.

Note:

The solution set must not contain duplicate triplets.

Example:

Given array nums = [-1, 0, 1, 2, -1, -4],

A solution set is:
[
  [-1, 0, 1],
  [-1, -1, 2]
]

給定一個包含 
n
 個整數的數組 
nums
，判斷 
nums
 中是否存在三個元素 
a，b，c ，
使得 
a + b + c = 
0 ？找出所有滿足條件且不重複的三元組。

    挺有趣的一題，反覆確認了一下，題目沒有時間複雜度的要求，那麼三層循環依次尋找就成爲了最簡單的寫法了，有興趣的同學可以自己寫寫看，這裏就不寫了。雖然題目沒有要求，但是身爲程序猿好歹還是要有點極客精神，單純的使用枚舉法就有點low了。

    觀察一下數組，發現例子給的是無序數組，但是假如我們把數組變爲有序確可以幫助我們優化算法，那麼就假定第一步是對數組進行排序。

//不想寫排序算法的同學可以這樣。
    //Arrays.sort(nums);
    public void sort(int[] nums, int left, int right){

        if (left > right)
            return;

        int tempLeft = left;
        int tempRight = right;

        int x = nums[left];

        while (left < right){

            while (left<right && x < nums[right])
                right--;
            if (left < right)
                nums[left++] = nums[right];

            while (left<right && x > nums[left])
                left++;

            if (left < right)
                nums[right--] = nums[left];
        }

        nums[left] = x;

        sort(nums, tempLeft, tempRight - 1);
        sort(nums, tempLeft + 1, tempRight);
    }

排序之後，以上面那個例子爲例

nums = [-4,-1,-1,0, 1, 2]

如nums[0]+nums[1]+nums[5]<0那麼我們明確知道nums[5]前面的都比他小，則本次循環可以跳出了

如nums[1]+nums[2]+nums[4]==0,那麼還需要繼續往前尋找，直到出現上述情況。

public List<List<Integer>> threeSum(int[] nums) {
        
        sort(nums, 0, nums.length - 1);

        List<List<Integer>> resultList = new ArrayList<>();
        for (int i = 0; i < nums.length; i++) {
            int left = i + 1;
            int right = nums.length - 1;
            while (left < right){
                if (nums[i] + nums[left] + nums[right] == 0){
                    resultList.add(Arrays.asList(nums[i], nums[left], nums[right]));
                    right--;
                }else if (nums[i] + nums[left] + nums[right] < 0){
                    left++;
                }else {
                    right--;
                }
            }
        }
        return resultList;
    }

寫完了上面的代碼運行，發現和例子中的結果不一樣，例子中還需要去重。加上去掉重複數據的代碼。其實也可以得到resultList之後再進行去重，但是如此就多進行了循環，所以需要在循環的過程中就去掉重複數據。

    public List<List<Integer>> threeSum(int[] nums) {

        sort(nums, 0, nums.length - 1);

        List<List<Integer>> resultList = new ArrayList<>();
        for (int i = 0; i < nums.length - 2; i++) {
            int left = i + 1;
            int right = nums.length - 1;
            while (left < right){
                if (nums[i] + nums[left] + nums[right] == 0){
                    resultList.add(Arrays.asList(nums[i], nums[left], nums[right]));
                    right--;
                    left++;

                    while (left < right && nums[left] == nums[left - 1])
                        left++;
                    while (left < right && nums[right] == nums[right + 1])
                        right--;
                }else if (nums[i] + nums[left] + nums[right] < 0){
                    left++;
                }else {
                    right--;
                }
            }

            while (i < nums.length - 2 && nums[i] == nums[i+1])
                i++;
        }
        return resultList;
    }

在LeetCode提交過程中出現了一件很尷尬的事情，如果對JDK源碼熟悉的同學應該已經發現了，我特麼寫的快排在複雜數據面前並沒有Arrays.sort()來的效率高，導致提交的時候出現了超時，很尷尬啊。

簡單看了下Arrays.sort()源碼

static void sort(int[] a, int left, int right,
                     int[] work, int workBase, int workLen) {
        // Use Quicksort on small arrays
        if (right - left < QUICKSORT_THRESHOLD) {
            sort(a, left, right, true);
            return;
        }

….

private static void sort(int[] a, int left, int right, boolean leftmost) {
        int length = right - left + 1;

        // Use insertion sort on tiny arrays
        if (length < INSERTION_SORT_THRESHOLD) {
            if (leftmost) {

JDK中根據數組的長度採用了快排、插入、等多種排序方法，血的教訓告訴我們，實際開發過程中儘量避免重複的造輪子，當然學習的過程中就不要怕犯錯了。

點擊查看更多解法

点赞