leetcode1

方案一：算法思想：两层循环。时间负责度：O(n^2)，空间复杂度O(1)。代码使用C#实现：

public class Solution
    {
        public int[] TwoSum(int[] nums, int target)
        {
            var ary = 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)
                    {
                        ary[0] = i;
                        ary[1] = j;
                        return ary;
                    }
                }
            }
            return ary;
        }
    }

 

方案二：算法思想：哈希。使用空间换取时间，时间复杂度：O(n)，空间复杂度：O(n)。代码使用python实现：

class Solution:
    def twoSum(self, nums: 'List[int]', target: 'int') -> 'List[int]':
        s = {}
        for i in range(len(nums)):
            n = nums[i]
            cop = target - n
            if cop in s.keys():
                return [s[cop],i]
            s[nums[i]] = i
        return  []

算法分析：

为方便理解，先定义一个概念——“补”。

假设a + b = target，则定义：在目标为target的情况下，a 是 b 的补，同样 b 是 a 的补。

使用字典s来存储已经遍历过的数值的“补”，即目标值与已遍历的值的差。

这样在遍历到一个新值时，如果 当前值 与s中已经存在的key相同，则表示当前值是已经遍历过的另一个值的“补”。

则可以获得本题所要求的两个和为target的数值的下标。

 

Java版：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int l = nums.length;
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        for(int i=0;i<l;i++){
            int cur = nums[i];
            int dif = target - cur;
            if(map.containsKey(cur)){
                int[] result = new int[2];
                result[0] = map.get(cur);
                result[1] = i;
                return result;
            }else{
                map.put(dif,i);
            }
        }
        return new int[2];
    }
}