LeetCode #1 两数之和

首先想到的应该就是这样一个循环的解决方案，但是这会带来平方级的复杂度

JAVA

class Solution {
    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[i] + nums[j] == target) {
                    return new int[]{i, j};
                }
            }
        }
		return new int[]{0,0};
    }
}

C++

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> result;
        for(int i=0;i<nums.size();i++){
            for(int j=i+1;j<nums.size();j++){
                if(nums[i]+nums[j]==target){
                    result.push_back(i);
                    result.push_back(j);
                    return result;
                }
            }
        }
        return result;
    }
};

C

int* twoSum(int* nums, int numsSize, int target) {
    int* result = malloc(2*sizeof(int));
    for(int i=0;i<numsSize;i++){
        for(int j=i+1;j<numsSize;j++){
            if(nums[i]+nums[j]==target){
                result[0]=i;
                result[1]=j;
                return result;
            }
        }
    }
    return result;
}

python

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        num_len = len(nums)
        for i in range(0,num_len):
            for j in range(i+1,num_len):
                if nums[i] + nums[j] == target:
                    return i,j
        return i,j

想要在线性复杂度解决问题，我们需要使用Hash表，这样能显著提升性能
JAVA

    class Solution {
        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++) {
                Integer num = nums[i];
                if (map.containsKey(target - num)) {
                    if (!(num * 2 == target && map.get(num) == i)) {
                        return new int[]{i, map.get(target - num)};
                    }
                }
            }
            return null;
        }
    }

Python

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        nums_len = len(nums)
        map = {}
        for i in range(nums_len):
            map[nums[i]] = i
        for i in range(nums_len):
            num = nums[i]
            if map.__contains__(target - num):
                if not (num*2 == target and map[num] == i):
                    return i,map[target - num]