打卡 DAY 22 四数之和

最新推荐文章于 2024-10-17 23:22:01 发布

吗喽仔

最新推荐文章于 2024-10-17 23:22:01 发布

阅读量51

点赞数

文章标签：数据结构算法

本文链接：https://blog.csdn.net/m0_74776011/article/details/130466145

版权

文章详细介绍了如何使用类似于三数之和的思路解决力扣上的四数之和问题，通过嵌套循环和快速排序降低时间复杂度至O(n^3)，同时处理了数值溢出问题和重复元素的剪枝操作。代码实现中包含了动态内存分配和管理。

摘要由CSDN通过智能技术生成

力扣原题链接

一、题目描述

二、思路

跟打卡 DAY 21 三数之和思路相同，其中有变化的就是for中需要再嵌套一个for，同样的解题思路可以去解五数之和、六数之和等等，这种方法能将时间复杂度降一个数量级；除此之外，进行的剪枝操作也会稍有不同。

三、解题过程

参照：打卡 DAY 21 三数之和

四、代码

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */

void swap(int *p, int *q){
    int tmp = *p;
    *p = *q;
    *q = tmp;
}

void QuickSort(int* arr, int begin, int end){
    if(begin >= end) return;
    int key = arr[begin];
    int left = begin;
    int right = end;
    while(left < right){
        while(left < right && arr[right] >= key) right --;
        while(left < right && arr[left] < key) left ++;
        swap(&arr[left], &arr[right]);
    }
    swap(&arr[begin], &arr[left]);
    QuickSort(arr, begin, left);
    QuickSort(arr, left + 1, end);
}

int** fourSum(int* nums, int numsSize, int target, int* returnSize, int** returnColumnSizes){
    QuickSort(nums, 0, numsSize - 1);
    int** res = (int**)malloc(sizeof(int*)*18000);
    int left, right;
    int index = 0;
    for(int i = 0; i < numsSize - 3; i++){
        if(nums[i] > target && target > 0) break;
        if(i > 0 && nums[i] == nums[i - 1]) continue;
        for(int j = i + 1; j < numsSize - 2; j++){
            if(nums[i] + nums[j] > target && target > 0) break;
            if(j > i + 1 && nums[j] == nums[j - 1]) continue;
            left = j + 1;
            right = numsSize - 1;
            while(left < right){
                long long sum = (long long)nums[i] + (long long)nums[j] + (long long)nums[left] + (long long)nums[right];
                if(sum < target) left ++;
                else if(sum > target) right --;
                else{
                    int* arr = (int*)malloc(sizeof(int) * 4);
                    arr[0] = nums[i];
                    arr[1] = nums[j];
                    arr[2] = nums[left];
                    arr[3] = nums[right];
                    res[index ++] = arr;
                    while(left < right && nums[right] == nums[right - 1]) right --;
                    while(left < right && nums[left] == nums[left + 1]) left ++;
                    right --;
                    left ++;
                }
            }
        }
    }
    *returnSize = index;
    *returnColumnSizes = (int*)malloc(sizeof(int) * index);
    for(int k = 0; k < index; k ++){
        (*returnColumnSizes)[k] = 4;
    }
    return res;
}

时间复杂度：O(n^3)。