[LeetCode] 18.四数之和（Medium）C语言题解

题目

• 给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

注意：答案中不可以包含重复的四元组。

---

示例

①示例1

• 给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。
• 满足要求的四元组集合为：
  [
  [-1, 0, 0, 1],
  [-2, -1, 1, 2],
  [-2, 0, 0, 2]
  ]

---

说明

①相关话题

• 哈希表
• 排序
• 双指针

②相似题目

• 1. 两数之和 — 力扣网
• 1. Two Sum — leetcode
• 15. 三数之和 — 力扣网
• 15. 3Sum — leetcode

③题目地址

• 18. 四数之和 — 力扣网
• 18. 4Sum — leetcode

---

解题方法

①排序 + 双指针

• 定义四个指针：i、j、pos1、pos2，遍历 i，则问题可以转化为在 i 之后的数组中寻找 nums[j]+nums[pos1]+nums[pos2] = -nums[i]，即将四数之和的问题转化为三数之和。
• 三数之和求解：遍历 j，则问题可以转化为在 j 之后的数组中寻找 nums[pos1]+nums[pos2] = -nums[j]，即将三数之和的问题转化为两数之和。
• 令数组有序，两数之和的问题就可使用双指针(pos1、pos2)碰撞求解。
• 时间复杂度：O(N^3)。
• 空间复杂度：O(1)。

②排序 + 哈希表

• 由于题目对运行速度的要求很高，这里的哈希表直接使用 uthash，节省空间。
• uthash 是一个用 C 语言编写的开源库，使用宏实现了哈希表的增删改查等功能。
• 将 15. 三数之和 — 力扣网 的 a + b + c = 0 看作 a + b + c = -d + target，即可求解本题。
• 对比于 15. 三数之和 — 力扣网 等式右边的 0，此题的等式右边变成了 数组 nums 中的任意值+target。
• 所以在排序后，使用三层 for 循环，第一层循环每次更换 d 值(nums[i])，内层循环在 d 后的数组中寻找和等于 -target-c 的三个值(可能有多种组合)，寻找方法参考 15.三数之和。
• 寻找方法：第二层循环每次更换 c 值(nums[j])，第三层循环在 c 后的数组中寻找和等于 target-c-d 的两个值，寻找方法参考 1.两数之和 — uthash。
• 时间复杂度：O(N^3)。
• 空间复杂度：O(N)。

---

代码详解

• 排序 + 双指针

// 快排函数(升序)。
int compare(const void* a, const void* b) {
    return (*(int*)a)-(*(int*)b);
}

int** fourSum(int* nums, int numsSize, int target, int* returnSize) {
    int** result = malloc(sizeof(int*)*numsSize*numsSize);
    *returnSize = 0;
    
    qsort(nums, numsSize, sizeof(int), compare);   

    for (int i = 0; i < numsSize-3; i++) {
        if (i > 0 && nums[i] == nums[i-1])
            continue;
        for (int j = i+1; j < numsSize-2; j++) {
            int pos1 = j+1, pos2 = numsSize-1, n = nums[i]+nums[j];
            
            // 去除重复值。
            if (j > i+1 && nums[j] == nums[j-1])
                continue;
            // 双指针首尾碰撞。
            while (pos1 < pos2) {
                if (nums[pos1]+nums[pos2] < target-n)
                    pos1++;
                else if (nums[pos1]+nums[pos2] > target-n)
                    pos2--;
                else {
                    result[*returnSize] = malloc(sizeof(int)*4);    
                    result[*returnSize][0] = nums[i];
                    result[*returnSize][1] = nums[j];
                    result[*returnSize][2] = nums[pos1];
                    result[*returnSize][3] = nums[pos2]; 
                    (*returnSize)++;     
                    pos1++;
                    pos2--;
                
                    // 去除重复值。
                    while (pos1 < numsSize && nums[pos1] == nums[pos1-1])
                        pos1++;
                    while (pos2 >= j+1 && nums[pos2] == nums[pos2+1])
                        pos2--;
                }
            }   
            if (nums[j] > 0 && nums[j] >= target)
                break;
        }
        if (nums[i] > 0 && nums[i] >= target)
            break;
    }
        
    return result;
}

• 排序 + 哈希表(uthash)

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

int** fourSum(int* nums, int numsSize, int target, int* returnSize) {
    struct hash {
        int value;
        UT_hash_handle hh; 
    };
    
    int** result = malloc(sizeof(int*)*numsSize*numsSize);
    *returnSize = 0;
    qsort(nums, numsSize, sizeof(int), compare);      

    // 可以转化成 15.三数之和，即a+b+c=target-d。
    for (int i = 0; i < numsSize-3; i++) {
        // 去除重复值。
        if (i > 0 && nums[i] == nums[i-1])
            continue;
        // 可以转化成 1.两数之和，即a+b=target-c-d。
        for (int j = i+1; j < numsSize-2; j++) {
            struct hash *hashTable = NULL;
            
            // 去除重复值。
            if (j > i+1 && nums[j] == nums[j-1])
                continue;
            // 寻找两个数，使其和等于target-c-d。    
            for (int k = j+1; k < numsSize; k++) {
                struct hash *h;
                // 边将nums[k]添加到哈希表中，边检查每个元素所对应的目标元素(target-nums[i]-nums[j]-nums[k])是否存在于表中。
                int diff = target-nums[i]-nums[j]-nums[k];
                HASH_FIND_INT(hashTable, &diff, h);
            
                if (!h) {
                    h = malloc(sizeof(struct hash));
                    h->value = nums[k];
                    HASH_ADD_INT(hashTable, value, h);
                }
                else {
                    result[*returnSize] = malloc(sizeof(int)*4);
                    result[*returnSize][0] = nums[i]; 
                    result[*returnSize][1] = nums[j]; 
                    result[*returnSize][2] = nums[k];
                    result[*returnSize][3] = h->value;
                    (*returnSize)++;
                
                   // 去除重复值。
                    while (k+1 < numsSize && nums[k+1] == nums[k])
                        k++;
                }
            }
            if (nums[j] > 0 && nums[j] >= target)
                break;
        }
        if (nums[i] > 0 && nums[i] >= target)
            break;
    }
    
    return result;
}

---

附录

• 我的个人博客：messi1002.top
• 如有错误或疑惑之处 请联系 wjymessi@163.com
• 所有题目解答：fork me on github