两数之和

问题描述：

给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。

你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

---

解答：

public class _001_TwoSum : MonoBehaviour
{
    /// <summary>
    /// 解决方法
    /// </summary>
    /// <param name="nums"></param>
    /// <param name="target"></param>
    /// <returns></returns>
    public int[] TwoSum(int[] nums, int target)
    {

        for (int i = 0; i < nums.Length - 1; i++)
        {
            for (int j = i + 1; j < nums.Length; j++)
            {
                if (nums[i] + nums[j] == target)
                {
                    return new int[] { i, j };
                }
            }
        }
        throw new System.Exception("没有找到对应两数相加等于：  " + target + "  的索引！");
    }



    //测试：
    void Start ()
    {
        //int[] nums =new int[]{ 1,3,5,7};
        int[] nums = Utilit.CreatRandArray(2, 10, 4);

        int[] res = TwoSum(nums, 6);

        Debug.Log("目标两数的索引数组：" + Utilit.PrintArray(res));
    }

   
}

---

测试结果：

img.jpg

工具类：(用来产生随机数组与输出结果)：

/// <summary>
/// 工具类：
/// </summary>
public class Utilit
{

    /// <summary>
    /// 生成随机数组
    /// </summary>
    /// <param name="min"></param>
    /// <param name="max"></param>
    /// <param name="len"></param>
    /// <returns></returns>
    public static int[] CreatRandArray(int min, int max, int len)
    {
        int[] a = new int[len];
        string str = null;
        for (int i = 0; i < a.Length; i++)
        {
            a[i] = Random.Range(min, max);
            str += a[i].ToString() + " ";
        }
        Debug.Log("生成随机数组：[ " + str + "]");
        return a;
    }

    /// <summary>
    /// 输出数组
    /// </summary>
    /// <param name="a"></param>
    /// <returns></returns>
    public static string PrintArray(int[] a)
    {
        string str = null;
        for (int i = 0; i < a.Length; i++)
        {
            str += a[i].ToString() + " ";
        }
        return "[ " + str + "]";
    }

}

---

优化方法1：两遍哈希表

为了对运行时间复杂度进行优化，我们需要一种更有效的方法来检查数组中是否存在目标元素。如果存在，我们需要找出它的索引。保持数组中的每个元素与其索引相互对应的最好方法是什么？哈希表。

通过以空间换取速度的方式，我们可以将查找时间从 O(n)降低到 O(1)。哈希表正是为此目的而构建的，它支持以 近似 恒定的时间进行快速查找。我用“近似”来描述，是因为一旦出现冲突，查找用时可能会退化到 O(n)O(n)。但只要你仔细地挑选哈希函数，在哈希表中进行查找的用时应当被摊销为 O(1)。

一个简单的实现使用了两次迭代。在第一次迭代中，我们将每个元素的值和它的索引添加到表中。然后，在第二次迭代中，我们将检查每个元素所对应的目标元素（target - nums[i]）是否存在于表中。注意，该目标元素不能是 nums[i]本身！

java:

public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        map.put(nums[i], i);
    }
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (map.containsKey(complement) && map.get(complement) != i) {
            return new int[] { i, map.get(complement) };
        }
    }
    throw new IllegalArgumentException("No two sum solution");
}

复杂度分析：
时间复杂度：O(n)， 我们把包含有 n个元素的列表遍历两次。由于哈希表将查找时间缩短到 O(1)，所以时间复杂度为 O(n)。
空间复杂度：O(n)， 所需的额外空间取决于哈希表中存储的元素数量，该表中存储了 n个元素。

---

优化方法2：一遍哈希表

事实证明，我们可以一次完成。在进行迭代并将元素插入到表中的同时，我们还会回过头来检查表中是否已经存在当前元素所对应的目标元素。如果它存在，那我们已经找到了对应解，并立即将其返回。

java:

public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (map.containsKey(complement)) {
            return new int[] { map.get(complement), i };
        }
        map.put(nums[i], i);
    }
    throw new IllegalArgumentException("No two sum solution");
}

复杂度分析：
时间复杂度：O(n)， 我们只遍历了包含有 n 个元素的列表一次。在表中进行的每次查找只花费 O(1) 的时间。
空间复杂度：O(n)， 所需的额外空间取决于哈希表中存储的元素数量，该表最多需要存储 n个元素。