LeetCode 1.The Sum_leecode所有满足the sum-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_28297463/article/details/78785638

The Sum

Given an array of integers, return indices of the two numbers such
that they add up to a specific target. You may assume that each input
would have exactly one solution, and you may not use the same element
twice.

给定一个整数数组，返回两个数字的索引，使它们加起来成为一个特定的目标。

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

个人思路：

两层for循环暴力求解。外层循环i从0到数组的长度，内层循环j从i的后一位开始循环，避免对同一个数字循环两次。然后判断数组下标为i和j的数字之和是否满足目标值，若满足，则返回这两个下标。需要注意的是返回的的下标是一个数组。

代码如下：

public class Solution {
    public int[] TwoSum(int[] nums, int target) {
        int[] arr = new int[2];
        for (int i = 0; i < nums.Length; i++)
        {
            for (int j = i + 1; j < nums.Length; j++)
            {
                if (nums[i] + nums[j] == target)
                {
                    arr[0] = i;
                    arr[1] = j;
                }
             }
        }
        return arr;
    }
}

官方解答：

方法＃1（暴力）[接受]

暴力方法很简单。遍历每个元素Xx并找出是否有另一个值等于 $target-x$

public int[] twoSum(int[] nums, int target) {
    for (int i = 0; i < nums.length; i++) {
        for (int j = i + 1; j < nums.length; j++) {
            if (nums[j] == target - nums[i]) {
                return new int[] { i, j };
            }
        }
    }
    throw new IllegalArgumentException("No two sum solution");
}

复杂性分析:

时间复杂度：为O(n^2)。对于每个元素，我们试图通过循环其余的数组来找到它的补充集上O(n)时间。所以时间复杂度是为O(n^2)。
空间复杂度：O(1)

方法2（双向哈希表）[接受]

为了提高我们的运行时间复杂度，我们需要一个更有效的方法来检查数组中是否存在补充。如果存在补充，我们需要查找它的索引。维护数组中每个元素到索引的映射的最佳方法是什么？一个哈希表。
我们从缩短查找时间O(n)到O(1)以交易空间为速度。哈希表正是为此目的而构建的，它支持在接近恒定的时间快速查找。说“近”，因为如果发生碰撞，查找可能退化为O(n)时间。但在哈希表中查找应摊销O(1)时间，只要仔细选择散列函数。
一个简单的实现使用两个迭代。在第一次迭代中，我们将每个元素的值及其索引添加到表中。然后，在第二次迭代中，我们检查每个元素的补充 $target-nums[i]$ 存在于表中。注意，补充一定不能是nums[i]本身！

//官方给出的是java版本，这里我修改为C#的实现
public static int[] twoSum(int[] nums, int target)
        {
            Dictionary<int, int> dic = new Dictionary<int, int>();
            for (int i = 0; i < nums.Length; i++)
            {
                dic.Add(nums[i], i);
            }
            for (int i = 0; i < nums.Length; i++)
            {
                int complement = target - nums[i];
                if (dic.ContainsKey(complement) && dic[complement] != i)
                {
                    return new int[] { i, dic[complement] };
                }
            }
            throw new ArgumentException("No two sum solution");
        }

复杂性分析：

时间复杂度：O(n)。我们遍历包含的列表n个元素恰好两次。由于散列表减少了查找时间O(1)，时间复杂度是上O(n)。
空间复杂度：O(n)。所需的额外空间取决于哈希表中存储的项目数量，该数据存储的确切数量n个元素。

方法3（一次散列表）[接受]

事实证明，我们可以一次完成。当我们迭代并向表格中插入元素时，我们也回头检查当前元素的补充是否已经存在于表格中。如果存在，我们已经找到了解决办法，并立即返回。

public static int[] twoSum(int[] nums, int target)
        {
            Dictionary<int, int> dic = new Dictionary<int, int>();
            for (int i = 0; i < nums.Length; i++)
            {
                int complement = target - nums[i];
                if (dic.ContainsKey(complement))
                {
                    return new int[] { dic[complement], i };
                }
                dic.Add(nums[i], i);
            }
            throw new ArgumentException("No two sum solution");
        }