剖析三数之和：算法优化与实战 | 豆包MarsCode AI刷题

用户835661580810
192 阅读11分钟

三数之和问题是一个经典的算法问题，给定一个整数数组，找出所有满足三数之和为 0 的不重复三元组。

这个问题在算法领域中具有一定的挑战性和实用性。首先，我们需要明确问题的要求，即从给定的整数数组中找出所有满足三数之和为 0 的不重复三元组。

对于这个问题，一种常见的解法是先对数组进行排序，然后使用双指针法来遍历数组。排序的目的是为了方便后续的双指针操作，因为排序后的数组可以更好地利用元素之间的大小关系来进行判断和移动指针。

具体的解题思路如下：

  1. 对给定的整数数组进行排序。这一步可以使用现有的排序算法，如快速排序等。排序后的数组可以让我们更好地利用元素之间的大小关系来进行后续的操作。
  1. 准备三个指针。第一个指针从数组的头部开始遍历，第二个指针从第一个指针的下一个位置开始，第三个指针从数组的尾部开始。
  1. 移动指针的标准如下：
    • 如果三个指针指向的数据和等于 0，则收集此时的答案。并且将第二个指针向右移动一位，第三个指针向左移动一位。
    • 如果三个指针指向的数据和大于 0，说明此时的答案偏大，将第三个指针向左移动一位。
    • 如果三个指针指向的数据和小于 0，说明此时的答案偏小，将第二个指针向右移动一位。
    • 当左右指针重合或者交错时，将第一个指针向右移动一位，同时将第二个指针设置为第一个指针的下一个位置，第三个指针设置为数组的尾部。

通过这种方式，我们可以逐步遍历整个数组，找到所有满足三数之和为 0 的不重复三元组。

例如，对于输入数组 [-1,0,1,2,-1,-4]，经过排序后变为 [-4,-1,-1,0,1,2]。首先，第一个指针指向 -4，此时由于三个数之和小于 0，第二个指针向右移动一位。接着，第一个指针指向 -1，第二个指针指向 -1，第三个指针指向 2，此时三个数之和为 0，收集这个三元组。然后，继续移动指针，直到遍历完整个数组。

在实现这个算法时，需要注意以下几点：

  1. 去重操作。由于要求答案中不可以包含重复的三元组，所以在收集答案时需要进行去重操作。可以使用哈希表等数据结构来判断是否已经存在相同的三元组。
  1. 边界条件的处理。在移动指针时，需要注意边界条件的处理，避免指针越界。
  1. 时间复杂度和空间复杂度的分析。这个算法的时间复杂度主要取决于排序和双指针遍历的过程，一般为 O (n^2)，其中 n 是数组的长度。空间复杂度主要取决于存储答案的空间，一般为 O (1)（如果不考虑存储答案的空间，则为 O (n)，其中 n 是数组的长度）。

总之，三数之和问题是一个经典的算法问题，通过对数组进行排序和使用双指针法，可以有效地解决这个问题。在实现算法时，需要注意去重操作、边界条件的处理以及时间复杂度和空间复杂度的分析。

二、解题思路

  1. 排序数组
    • 首先对给定的数组进行排序，排序可以将相同的元素放在一起，有助于避免重复的组合，并且让我们更容易确定指针的移动方向。例如，对于输入数组 [-1,0,1,2,-1,-4]，经过排序后变为 [-4,-1,-1,0,1,2]。
  1. 固定第一个元素
    • 使用一个循环来遍历数组中的每一个元素，作为三元组中的第一个元素。
  1. 使用双指针
    • 在内层循环中，使用两个指针，一个指针指向固定元素后面的第一个元素，另一个指针指向数组的最后一个元素。
  1. 计算三数之和并根据大小移动指针
    • 计算当前的三数之和，根据三数之和与目标值的大小关系来移动指针。如果三数之和等于目标值，将这个三元组加入结果集。如果三数之和小于目标值，将左指针向右移动，以增加当前和的值。如果三数之和大于目标值，将右指针向左移动，以减小当前和的值。
  1. 处理重复元素
    • 在移动指针时跳过相同的元素，以避免得到重复的三元组。具体来说，当发现当前指针指向的元素与前一个元素相同时，继续移动指针直到找到不同的元素。这样可以确保结果集中不包含重复的三元组。

三、代码实现

以下以 Java 和 Python 为例展示三数之和问题的代码实现。

Java 实现

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ThreeNum_zhu {
    public static List<List<Integer>> threeNum(int[] nums) {
        // 双指针法
        Arrays.sort(nums);
        List<List<Integer>> ret = new ArrayList<>();
        for (int i = 0; i < nums.length - 2; i++) {
            // 因为是排序过的,所以有元素>0,从前往后找就找不到
            if (nums[i] > 0) break;
            if (i > 0 && nums[i] == nums[i - 1]) {
                // 避免重复的三元组
                continue;
            }
            int left = i + 1;
            int right = nums.length - 1;
            while (left < right) {
                int sum = nums[i] + nums[left] + nums[right];
                if (sum == 0) {
                    ret.add(Arrays.asList(nums[i], nums[left], nums[right]));
                    while (left < right && nums[left] == nums[left + 1]) {
                        left++; // 避免重复元素
                    }
                    while (left < right && nums[right] == nums[right - 1]) {
                        right--; // 避免重复元素
                    }
                    // 找到一组后,继续寻找
                    left++;
                    right--;
                } else if (sum > 0) {
                    // 如果和大于 0,需减小值大小,右指针往左移动
                    right--;
                } else {
                    // 如果和小于 0,需增加值大小,左指针往右移动
                    left++;
                }
            }
        }
        return ret;
    }
    public static void main(String[] args) {
        int[] nums = new int[]{-1, 0, 1, 2, -1, -4};
        System.out.println(threeNum(nums));
    }
}

Python 实现

def three_sum(nums):
    nums.sort()
    result = []
    n = len(nums)
    for i in range(n):
        if i > 0 and nums[i] == nums[i - 1]:
            continue  # 跳过重复的元素
        left, right = i + 1, n - 1
        while left < right:
            total = nums[i] + nums[left] + nums[right]
            if total < 0:
                left += 1
            elif total > 0:
                right -= 1
            else:
                result.append([nums[i], nums[left], nums[right]])
                left += 1
                right -= 1
                while left < right and nums[left] == nums[left - 1]:
                    left += 1  # 跳过重复的元素
                while left < right and nums[right] == nums[right + 1]:
                    right -= 1  # 跳过重复的元素
    return result

四、算法优化

  1. 去除重复计算通过一些判断条件，避免重复计算相同的三元组。

在三数之和问题中，去除重复计算是非常重要的优化步骤。可以通过在遍历过程中，比较当前元素与前一个元素是否相同来避免重复计算。例如，在遍历数组时，如果当前元素与前一个元素相等，那么可以直接跳过这个元素，继续下一个元素的遍历。这样可以避免产生重复的三元组。具体来说，在固定第一个元素后，当遍历第二个和第三个元素时，如果发现当前元素与前一个元素相同，就继续移动指针，直到找到不同的元素。这样可以确保结果集中不包含重复的三元组。

  1. 利用哈希表在某些情况下，可以使用哈希表来优化算法，减少时间复杂度。

使用哈希表可以有效地优化三数之和问题的算法。可以将数组中的元素存储在哈希表中，然后通过查找哈希表来快速确定是否存在满足条件的三元组。具体来说，可以在遍历数组时，将每个元素作为键，其出现的次数作为值存储在哈希表中。然后，在确定第一个元素后，可以在哈希表中查找是否存在两个元素的和为第一个元素的相反数。如果存在，就可以得到一个满足条件的三元组。使用哈希表可以将时间复杂度从 O (n^2) 降低到 O (n^2 * log (n))，提高算法的效率。

  1. 二分查找在确定了第一个数和第二个数之后，可以使用二分查找来快速找到第三个数。

在确定了第一个数和第二个数之后，可以使用二分查找来快速找到第三个数。具体来说，可以先对数组进行排序，然后在确定了第一个数和第二个数之后，使用二分查找在剩余的数组中查找第三个数。这样可以将时间复杂度从 O (n^2) 降低到 O (n^2 * log (n))，提高算法的效率。

在实现二分查找时，需要注意以下几点：

  1. 确定查找的范围。在确定了第一个数和第二个数之后，可以确定第三个数的范围。如果三个数之和小于目标值，那么第三个数应该在当前查找范围的右侧；如果三个数之和大于目标值，那么第三个数应该在当前查找范围的左侧。
  1. 确定查找的中间值。可以使用二分查找的方法来确定查找的中间值。具体来说，可以将查找范围的左右边界相加，然后除以 2，得到中间值的索引。
  1. 比较中间值与目标值的大小。将中间值与目标值进行比较，如果中间值等于目标值，那么就找到了第三个数；如果中间值小于目标值，那么第三个数应该在中间值的右侧；如果中间值大于目标值，那么第三个数应该在中间值的左侧。

通过使用二分查找，可以快速找到第三个数，提高算法的效率。

五、总结

三数之和问题作为经典的算法问题，其解题思路和算法优化方法在算法学习中具有重要意义。

首先，解题思路主要包括以下几个步骤：对给定数组进行排序，固定第一个元素，然后使用双指针法，通过计算三数之和并根据大小移动指针，同时处理重复元素，确保结果集中不包含重复的三元组。

在算法优化方面，可以采取以下几种方法：

  1. 去除重复计算：在遍历过程中，比较当前元素与前一个元素是否相同，避免重复计算相同的三元组。例如，在固定第一个元素后，当遍历第二个和第三个元素时，如果发现当前元素与前一个元素相同，就继续移动指针，直到找到不同的元素。
  1. 利用哈希表：将数组中的元素存储在哈希表中，通过查找哈希表来快速确定是否存在满足条件的三元组。可以在遍历数组时，将每个元素作为键，其出现的次数作为值存储在哈希表中。然后，在确定第一个元素后，可以在哈希表中查找是否存在两个元素的和为第一个元素的相反数。使用哈希表可以将时间复杂度从 O (n²) 降低到 O (n² * log (n))，提高算法的效率。
  1. 二分查找：在确定了第一个数和第二个数之后，可以使用二分查找来快速找到第三个数。先对数组进行排序，然后在确定了第一个数和第二个数之后，使用二分查找在剩余的数组中查找第三个数。这样可以将时间复杂度从 O (n²) 降低到 O (n² * log (n))，提高算法的效率。在实现二分查找时，需要注意确定查找的范围、查找的中间值以及比较中间值与目标值的大小。

总之，三数之和问题的解题思路和算法优化方法为我们解决其他类似问题提供了有益的参考和借鉴。通过深入理解和掌握这些方法，可以提高我们的算法设计和实现能力，更好地应对各种算法挑战。

avatar
文章
阅读
粉丝