leetcode01_TwoSum

一.问题描述

Two 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.

Example:

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

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

UPDATE (2016/2/13):
The return format had been changed to zero-based indices. Please read the above updated description carefully.

二.编写代码

1.输入：无序，有负，list

2输出：序号，假设唯一

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

代码分析：两层for循环，时间复杂度O(N^2)

三.算法优化

1.通过计算输入list中的最大最小值，直接跳过不可能的值。

改进代码如下：

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        #优化：有负数，但是可以通过list里面的最大最小值来continue一部分数值
        len_nums=len(nums)
        #最大最小值初始化
        max=nums[0]
        min=nums[0]
        for i in range(0,len_nums):
            if nums[i]<min:
                min=nums[i]
            if nums[i]>max:
                max=nums[i]
        #求出list中所允许的最大值和最小值
        max_list=target-min
        min_list=target-max
        for i in range(0,len_nums):
            if nums[i]>max_list:
                continue
            if nums[i]<min_list:
                continue
            for j in range(i+1,len_nums):
                if nums[i]+nums[j]==target:
                    return [i,j]

可见，对算法的性能优化并不十分理想。

2.对list进行排序

结果竟然有了质的飞跃！~~~~

看代码：

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        #优化：对list进行排序
        #将排序好的list赋给一个新的list，保留原序号
        nums_sorted=sorted(nums)
        i=0
        j=len(nums)-1
        while(i<j):
            sum=nums_sorted[i]+nums_sorted[j]
            if sum==target:
                #得到正确的加和数字，而不是list序号
                result=[nums_sorted[i],nums_sorted[j]]
                break
            elif sum<target:
                i=i+1
            else:
                j=j-1
        return_result=[]
        #最终通过判断得到返回的序号
        for i in range(0,len(nums)):
            if nums[i]==result[0] or nums[i]==result[1]:
                return_result.append(i)
        return return_result

进一步思考：感觉如果可以排序之后记住原序号这样会更好，也就是做一层map。

四.总结

感觉这种无序的，只能做两层for循环去判断（即复杂度为N^2）的问题，可以考虑先排序，这样复杂度一般可以保持在O(NlogN)。