当前位置：首页 > news >正文

三数之和

news 来源：原创 2025/5/15 12:41:25

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。

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

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

示例 3：

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

提示：

3 <= nums.length <= 3000
-105 <= nums[i] <= 105

解题思路：

先排序数组（从小到大）
- 排序后相同的数字会挨在一起，方便跳过重复解
- 排序后可以使用双指针技巧
固定第一个数（nums[i]）
- 从数组开头开始遍历，每次固定一个数作为三元组的第一个数
- 如果当前数和前一个数相同，就跳过（避免重复解）
使用双指针找另外两个数
- 左指针（left）从i+1开始
- 右指针（right）从数组末尾开始
- 计算三数之和：
  - 如果正好为0，记录下来
  - 如果小于0，左指针右移（需要更大的数）
  - 如果大于0，右指针左移（需要更小的数）
跳过重复元素
- 找到有效解后，跳过左右指针相同的相邻元素

代码：

#include <stdlib.h>
#include <string.h>

// 比较函数，用于排序
int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int** threeSum(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    // 1. 排序数组（升序）
    qsort(nums, numsSize, sizeof(int), compare);
    
    // 2. 初始化结果存储
    int maxResults = numsSize * numsSize; // 预分配足够空间
    int** result = (int**)malloc(sizeof(int*) * maxResults);
    *returnColumnSizes = (int*)malloc(sizeof(int) * maxResults);
    *returnSize = 0; // 初始结果为0组

    // 3. 遍历固定第一个数 nums[i]
    for (int i = 0; i < numsSize - 2; i++) {
        // 跳过重复的 nums[i]（去重）
        if (i > 0 && nums[i] == nums[i - 1]) {
            continue;
        }

        int left = i + 1;    // 左指针从 i+1 开始
        int right = numsSize - 1; // 右指针从末尾开始
        int target = -nums[i]; // 需要找 nums[left] + nums[right] = -nums[i]

        // 4. 双指针搜索
        while (left < right) {
            int sum = nums[left] + nums[right];
            
            if (sum == target) {
                // 找到有效三元组
                result[*returnSize] = (int*)malloc(sizeof(int) * 3);
                result[*returnSize][0] = nums[i];
                result[*returnSize][1] = nums[left];
                result[*returnSize][2] = nums[right];
                (*returnColumnSizes)[*returnSize] = 3; // 每组3个数
                (*returnSize)++;

                // 跳过重复的 left 和 right（去重）
                while (left < right && nums[left] == nums[left + 1]) left++;
                while (left < right && nums[right] == nums[right - 1]) right--;
                left++;
                right--;
            } else if (sum < target) {
                left++; // 需要更大的数
            } else {
                right--; // 需要更小的数
            }
        }
    }
    
    return result;
}