我的方法：复杂度sqrt(n).

思路：现将nums备份，将nums排序，再从两端逐步向中间靠拢，寻找nums[i]+nums[j]=target。输出nums[i]，nums[j]再备份中的index。函数list.index(value)

list.index（val,start,end）----在这个范围内寻找val第一次出现的index。

如果val出现多次，可以将前一次出现的index的位置另赋值。（但这个方法，不好）应该设定start，end的值。详见方法二。

def twoSum(self, nums, target):
        l=len(nums)
        s=[]
        s=nums
        nums=sorted(nums)
        i=0
        j=l-1
        while (i<l) & (j>i):            
            if nums[i]+nums[j]==target:
                temp_1=s.index(nums[i])
                s[temp_1]=3.5
                return [temp_1,s.index(nums[j])]
            elif nums[i]+nums[j]>target:
                j-=1
            else:
                i+=1

方法二：大神的，复杂度为n。遍历nums，得到target-i的值，如果这个值在nums中（if a in nums），直接输出list

.index（a,m+1,len(nums)）。否则继续遍历



    def twoSum(self, nums, target):
      for i in nums:
          a=target-i
          m=nums.index(i)
          if a in nums:
              try:
                  n=nums.index(a,m+1,len(nums))
                  return (m,n)
              except:
                  continue

方法三：复杂度为n

        if len(nums) <= 1:
            return False
        buff_dict = {}
        for i in range(len(nums)):
            if nums[i] in buff_dict:
                return [buff_dict[nums[i]], i]
            else:
                buff_dict[target - nums[i]] = i

和法二方法相似，创建dict，target-nums[i]为key，索引i为values。向后遍历，如果新的数在dict的key中，则输出dict[nums[ii]]的values和ii。

注：for key in dict:返回的是键。等于   for key in dict.keys()

 

方法四：java

import java.util.*;
class Solution{
	public int[] twoSum(int[] nums, int target) {
		int[] b=new int[2];  
		List<Integer> list = new ArrayList<>(); 
		for(int i=0;i<nums.length;i++) {
			list.add(target-nums[i]);
		}		
		for(int i=0;i<nums.length;i++) {
			int index = list.lastIndexOf(nums[i]);
			if(index>-1&&index!=i) {
				b[0]=i;
				b[1]=index;
			}
		}
		 return b;
	}