目前主要分为三个专栏，后续还会添加：

        专栏如下：                 C语言刷题解析       C语言系列文章       我的成长经历

感谢阅读！

初来乍到，如有错误请指出，感谢！

---

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

给定一个整数数组 `nums` 和一个目标值 `target`，返回数组中两个数的索引，使得这两个数相加等于目标值 `target`。

这个函数使用了嵌套循环来遍历数组中的每一对数字，直到找到满足条件的两个数。

int* twoSum(int* nums, int numsSize, int target, int* returnSize)
{
    // 外层循环，遍历数组中的每个元素
    for (int i = 0; i < numsSize; ++i)
    {
        // 内层循环，遍历外层循环当前元素之后的所有元素
        for (int j = i + 1; j < numsSize; ++j)
        {
            // 检查两个元素的和中是否等于目标值
            if (nums[i] + nums[j] == target)
            {
                // 如果找到满足条件的两个数，则分配一个大小为2的整数数组
                int* ret = malloc(sizeof(int) * 2);
                // 将两个数的索引存入数组
                ret[0] = i, ret[1] = j;
                // 设置返回数组的大小为2
                *returnSize = 2;
                // 返回结果数组
                return ret;
            }
        }
    }
    // 如果没有找到满足条件的两个数，则返回数组大小为0
    *returnSize = 0;
    // 返回NULL
    return NULL;
}

代码解释：

1. 函数定义：`int* twoSum(int* nums, int numsSize, int target, int* returnSize)` 是一个返回整数指针的函数。它接受四个参数：一个整数数组 `nums`，数组的大小 `numsSize`，目标值 `target`，以及一个指向整数 `returnSize` 的指针，用于返回结果数组的大小。

2. 双重循环：使用两个嵌套的 `for` 循环遍历数组 `nums`。外层循环变量 `i` 从 0 到 `numsSize - 1`，内层循环变量 `j` 从 `i + 1` 到 `numsSize - 1`。这样做是为了确保每个元素只被访问一次，并且不会重复计算相同的元素对。

3. 检查和：在内层循环中，检查 `nums[i] + nums[j]` 是否等于 `target`。如果找到满足条件的两个数，则进入下一步。

4. 分配内存和返回结果：如果找到满足条件的两个数，使用 `malloc` 分配一个大小为 2 的整数数组 `ret`。将两个数的索引 `i` 和 `j` 分别存入 `ret` 的第一个和第二个位置。然后，将 `returnSize` 设置为 2，表示结果数组的大小为 2。最后，返回结果数组 `ret`。

5. 没有找到结果：如果双重循环结束后没有找到满足条件的两个数，则将 `returnSize` 设置为 0，并返回 `NULL`。

性能分析：

这个算法的时间复杂度是 O(n^2)，其中 n 是数组 `nums` 的大小。这是因为对于数组中的每个元素，都需要遍历它之后的所有元素来检查是否存在一对和为 `target` 的数。对于较大的数组，这个算法可能会比较慢。

优化建议：

一种更高效的方法是使用哈希表来降低时间复杂度。具体做法是遍历数组，对于每个元素，计算 `target` 与该元素的差值，然后检查这个差值是否已经在哈希表中。如果存在，则找到了一对和为 `target` 的数；如果不存在，则将当前元素及其索引添加到哈希表中。这种方法的时间复杂度是 O(n)。