leetcode1两数之和

题目

思路

• 暴力法：先固定一个指针，再遍历它右边的数；相加等于target，返回；否则指针右移动。
• 哈希表法：用target依次减去每个数，看结果是否在哈希表中，有则返回，无则继续。

遇到的问题

java基础知识遗忘严重
这个题算是复习Java数组了

• 创建数组

dataType[] arrayRefVar = new dataType[arraySize];
dataType[] arrayRefVar = {value0, value1, ..., valuek};

举例

      // 数组大小
      int size = 10;
      // 定义数组
      double[] myList = new double[size];
      myList[0] = 5.6;
      myList[1] = 4.5;
      myList[2] = 3.3;
      myList[3] = 13.2;
      myList[4] = 4.0;

• 处理数组

//for each
for(type element: array)
{
    System.out.println(element);
}

数组作为函数的返回值

public static int[] reverse(int[] list) {
  int[] result = new int[list.length];
 
  for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
    result[j] = list[i];
  }
  return result;
}

• 数组越界问题
  数组arr的合法错误范围是**[0, arr.length-1]**
• Java返回两个变量的方法

return new int[] { i, j };

代码

• 暴力法

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

• 哈希表法

class Solution {
    // O(n) 哈希表（一次哈希）
    public int[] twoSum(int[] nums, int target) {
        if (nums != null) {
            HashMap<Integer, Integer> hashMap = new HashMap<>();
            for (int i = 0; i < nums.length; i++) {
                int temp = target - nums[i];
                if (hashMap.containsKey(temp))
                    return new int[]{hashMap.get(temp), i};
                else
                    hashMap.put(nums[i], i);
            }
        }
        return null;
    }
}

这里用Python的方法则更为简洁，list和diction都很方便

class Solution:
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        for i in range(len(nums)):
            if target-nums[i] in nums:
            #增加了返回的两个数下表不能相同的判断
                if i!=nums.index(target-nums[i]):
                    return i,nums.index(target-nums[i])

class Solution:
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        #遍历一个i,就把nums[i]放在字典里。之后i不断相加，总会碰到
        #target - nums[i]在字典里的情况。碰到的时候return即可。这里注意到先return的是dict[a],再是当前的i,原因就是dict里存的value都是以前遍历过的i,所以它比当前的i小，按从小到大的顺序所以这样排。
        dict = {}
        for i in range(len(nums)):
            a = target - nums[i]
            if a in dict:
                return dict[a],i
            else:
                dict[nums[i]] = i