LeetCode (力扣) 16. 3Sum Closest (C) - Medium 暴力解、双指标( Merge Sort )、双指标( Quick Sort )

同步发于 JuzerTech 网站，里面有我软、硬件学习的纪录与科技产品开箱，欢迎进去观看。

这题是 LeetCode 15. 3Sum ( C )-Medium 的变形题 。

题目为给定一串数字，寻找任意三个数字相加最接近目标值，并输出这三个数字的合。

 

题目与范例如下

Given an array nums of n integers and an integer target, find three integers in nums such that the sum is closest to target. Return the sum of the three integers. You may assume that each input would have exactly one solution.

Example 1:

Input: nums = [-1,2,1,-4], target = 1
Output: 2
Explanation: The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).

Constraints:

3 <= nums.length <= 10^3
-10^3 <= nums[i] <= 10^3
-10^4 <= target <= 10^4

---

 

下面分三总解法 1.暴力解、2.双指标( Merge Sort )、3.双指标( Quick Sort )

1 . 策略为开三个回圈一个个比较

2 . 解题策略为使用双指标，先透过 Merge Sort 将数列排序，使用 for 回圈遍历数列到倒数第三个数字，每次透过两个指标逼近数字。

3 . 解题策略为使用双指标，先透过 Quick Sort 将数列排序，使用 for 回圈遍历数列到倒数第三个数字，每次透过两个指标逼近数字。

 

下方为我的代码

1 . 暴力解

int threeSumClosest(int* nums, int numsSize, int target){
    if(numsSize<3)
        return 0;
    else{
        int closest= -999999;
        for(int i = 0 ; i < numsSize-2 ; i++ ){
            for(int j = i+1 ; j < numsSize-1 ; j++ ){
                for(int k = j+1;k<numsSize;k++){
                    if(abs(target - (nums[i]+nums[j]+nums[k]))<abs(target-closest))
                        closest = (nums[i]+nums[j]+nums[k]);
                }
            }
        }
        return closest;
    }
}

 

2 . 双指标( Merge Sort )

void mergeSort(int* num, int numsSize);
void sortsub(int* num, int low, int high);
void merge(int* num, int low, int middleL, int middleR, int high);

int threeSumClosest(int* nums, int numsSize, int target){
    int left = 0,right = 99999,closest = 99999,tempsum=0;
    mergeSort(nums,numsSize);
    
    for(int i = 0;i<numsSize-2;i++){
        left = i+1;
        right = numsSize-1;
        while(right>left){
            tempsum = nums[i]+nums[left]+nums[right];
            if(abs(target - tempsum)<abs(target - closest)){
                closest = tempsum;
            }
            if(tempsum<target){
                left++;
            }   
            else if(tempsum>target){
                right--;
            }
            else{
                break;
            }
        }
    }
    
    return closest;
}

void mergeSort(int* num, int numsSize) {
    sortsub(num, 0, numsSize - 1);
}

void sortsub(int* num, int low, int high) {
    if ((high - low) >= 1) {
        int middleL = (low + high) / 2;
        int middleR = middleL + 1;
        sortsub(num, low, middleL);
        sortsub(num, middleR, high);
        merge(num,low,middleL,middleR,high);
    }

}

void merge(int *num,int low,int middleL,int middleR, int high) {
    int combinedIndex = 0, leftIndex = low, rightIndex = middleR;
    int* tempArray = (int*)malloc(sizeof(int) * (high - low + 1));

    while (leftIndex <= middleL && rightIndex <= high) {
        if (num[leftIndex] < num[rightIndex]) {
            tempArray[combinedIndex++] = num[leftIndex++];
        }
        else
            tempArray[combinedIndex++] = num[rightIndex++];    
    }

    if (leftIndex > middleL) {
        while (rightIndex <= high) {
            tempArray[combinedIndex++] = num[rightIndex++];
        }
    }
    else {
        while (leftIndex <= middleL) {
            tempArray[combinedIndex++] = num[leftIndex++];
        }
    }

    for (int i = low; i <= high; i++) {
        num[i] = tempArray[i - low];
    }
}

 

3 . 双指标( Quick Sort )

int cmp(const void *a, const void *b){
    return *(int *)a - *(int *)b;
}


int threeSumClosest(int* nums, int numsSize, int target){
    int left = 0,right = 99999,closest = 99999,tempsum=0;
    qsort(nums, numsSize, sizeof(int), cmp);    // quick sort
    for(int i = 0;i<numsSize-2;i++){
        left = i+1;
        right = numsSize-1;
        while(right>left){
            tempsum = nums[i]+nums[left]+nums[right];
            if(abs(target - tempsum)<abs(target - closest)){
                closest = tempsum;
            }
            if(tempsum<target){
                left++;
            }   
            else if(tempsum>target){
                right--;
            }
            else{
                break;
            }
        }
    }
    return closest;
}

 

下方为时间与空间之消耗

1 .  暴力解

Runtime: 316 ms, faster than 10.98% of C online submissions for 3Sum Closest.

Memory Usage: 5.8 MB

2 .  双指标( Merge Sort )

Runtime: 20 ms, faster than 36.99% of C online submissions for 3Sum Closest.

Memory Usage: 7.9 MB

3 .  双指标( Quick Sort )

Runtime: 8 ms, faster than 73.41% of C online submissions for 3Sum Closest.

Memory Usage: 5.9 MB, less than 65.90% of C online submissions for 3Sum Closest.

 

采用双指标后大幅的提升执行效率，采用Quick Sort 又能稍微的提升速度。