1.两数之和

1.两数之和

方法一：暴力枚举

拿两个数，加起来看是不是 target

枚举数组中的每一个数 x，寻找数组中是否存在 target - x。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int [] result = new int [2];
        for(int i=0;i<nums.length;i++){
            int sub=target-nums[i];
            for(int j=i+1;j<nums.length;j++){
                if(sub==nums[j]){
                  result[0]=i;
                  result[1]=j;
                  return result;
                }
            }
            
        }
        return result;
    }
}
//时间复杂度：O (n²)

方法二：哈希表

思路： 拿一个数 num，看 target - num 有没有出现过，出现过就直接返回答案，没出现过就把当前数存起来。

只需要一次循环

使用哈希表，可以将寻找 target - x 的时间复杂度降低到从 O(N) 降低到 O(1)。

步骤：

0. 建一个哈希表，存 数值 → 下标

1. 历数组里每一个数 nums[i]

2. 算需要找的另一个数： int another = target - nums[i];

3. 看哈希表里有没有 another，

   有 → 直接返回 {表中another的下标, i} 没有 → 把 nums[i] 和 i 存进哈希表

4. 继续走，直到结束

   代码：

   import java.util.HashMap;//引入 Java 自带的哈希表工具
   ​
   class Solution {
       public int[] twoSum(int[] nums, int target) {
           HashMap<Integer, Integer> map = new HashMap<>();
           //创建一个哈希表 map
   ​
           for (int i = 0; i < nums.length; i++) {
               int another = target - nums[i];
   ​
               if (map.containsKey(another)) {
                   return new int[]{map.get(another), i};
               }
   ​
               map.put(nums[i], i);
           }
   ​
           return new int[0];
       }
   }
   

   知识点

   0. <>泛型

      作用：给容器 / 集合规定：里面只能装什么类型的数据。

      Java 规定：<> 泛型里不能写基本类型（int、double、boolean），必须写类类型（Integer、String、Double…）

      Integer = int 的包装类

   1. 哈希表

      HashMap<Integer, Integer> map = new HashMap<>();
      

      第一个 Integer：key（存数组里的数字）

      第二个 Integer：value（存数字对应的下标）

      三个方法：

      map.put(key, value)→ 把数据存进去

      map.get(key)→ 拿到这个数对应的下标

      map.containsKey(key)→ 查有没有这个数

      （map是我自己定义的对象名可以随便取）

   2. 定义数组格式

      int[] arr = new int[长度];
      int[] arr = {值1, 值2, 值3};
      

   3. Java返回数组格式

      return new int[]{值1, 值2};//注意[]后面是没有等号=的