LeetCode1（twoSum）的解法

1、双层for循环的解法：

    def AddTwoNum(self, nums, target):
        # print(nums)
        # for i in range(len(nums)-1):
        #
        #     for j in range(i+1,len(nums)):
        #
        #         if nums[i]+nums[j]==target:
        #             return [i,j]
        #         else:
        #             continue
        #             pass
        #         pass
        #     pass

双层for循环的时间复杂度是n的平方

改进思路：

第二层for循环里面，其实就是在数组nums里面找寻 j=target-nums[i]的值

这个可以考虑用hashmap做，因为hashmap的时间复杂度为O(1)

注意：hashmap里要把element作为key，index作为value，我们找某个element时候，就可以得到它的index（有多个index怎么办？把index拼接起来）

class Solution:
    def twoSum(self,nums,target):
        dictTemp={}
        for index,element in enumerate(nums):
            print(index,element)
            if dictTemp.get(element) is None:  #字典里还没有这个数的情况下，就存进去
                dictTemp[element] = str(index)
                pass
            else:
                dictTemp[element]=dictTemp[element]+","+str(index)   #出现2个3的时候怎么办？用，隔开两个index
                pass
        print("-----")
        for key,value in dictTemp.items():
            print(key,value)
            pass
        print("-----")

        for index,element in enumerate(nums):
            j=target-element   #目的就是在字典里找到这个数j
            if dictTemp.get(j) is None: #找不到target-element,接着往下走
                print("根本就没有这个j，接着看下一个数吧！")
                continue
                pass
            else:
                index2=dictTemp.get(j)  #能找到，但是要分情况，1个j的时候和存在多个j的时候
                if len(index2)==1:
                    index2=int(index2)
                    if index2 !=index:     #排除找到自己本身3的情况，6-3=3
                        return [index,index2]
                    pass
                else:
                    for x in index2:
                        if x != ",":
                            x=int(x)
                            print("打印X的值：{}".format(x))
                            if x!=index:
                                return [index,x]
                            else:
                                continue
                            pass
                        pass
                    pass
                pass






        # for index,element in enumerate(nums):
        #     j=dictTemp.get(target-element)
        #     if (j is not None) & (j != index):
        #         return [index,j]
        #     pass
        # pass

    #改进：不在整个dictTemp里面找target-element,只在该数据的前面找

    # def twoSum(self,nums,target):
    #     dictTemp={}
    #
    #     for index,element in enumerate(nums):
    #         if dictTemp.get(target-element) is not None:
    #             print("找到了")
    #             return [dictTemp.get(target-element),index]
    #         else:
    #             dictTemp[element]=index
    #             pass
    #         pass



    pass

s=Solution()
nums=[1,2,3,4,4,4]
target=6
answer=[]
answer=s.twoSum(nums,target)
print(answer)

这个题学到了：

python里的字典也就是java里的hashmap，他查找的时间复杂度是O(1)