【题库】每日一练，两数之和

每日一练 - 两数之和

• 题目描述：

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

进阶：你可以想出一个时间复杂度小于 O($n^2$) 的算法吗？

• 题目对应示例：

输入：nums = [3,2,4], target = 6
输出：[1,2]

• 解题思路：

  1. 思路一（二分法）时间思路,复杂度小于O(n²)

  public static int[] dichotomy(int[] nums, int target){
          int[] result = {0,1};
          /* 理想状态，nums的长度为2，说明只有两个数所以可以直接返回 */
          if(nums.length == result.length){
              return result;
          }
          /* 遍历取值数组开始校验 */
          for (int i = 0; i < nums.length; i++) {
              /* 将第一个值与第二个开始值【后推】和最后面的值【前推】做对比，是否满足相加等于target */
              result[0] = i;
              int num = target - nums[i];
              for (int j = i + 1, m = nums.length - 1; j < m ; j++ , m--){
                  /* 从前往后比较 */
                  if(num == nums[j]){
                      result[1] = j;
                      return result;
                  } else if(num == nums[m]){
                      result[1] = m;
                      return result;
                  }
              }
          }
          return result;
      }
  

  2. 思路二（四分法）时间思路,复杂度小于nO(logn)

  public static int[] quartering(int[] nums, int target){
          int[] result = {0,1};
          /* 理想状态，nums的长度为2，说明只有两个数所以可以直接返回 */
          if(nums.length == result.length){
              return result;
          }
          /* 遍历取值数组开始校验 */
          for (int i = 0,j = nums.length-1; i < j; i++,j--) {
              /* 在二分法的基础上定义两个标识，首和尾 */
              int start = target - nums[i];
              int end = target - nums[j];
  
              for(int k = i+1, m = j-1 ; k <= m; k++, m--){
                  result[0] = i;
                  /* 同时校验首尾 */
                  if(start == nums[m]){
                      result[1] = m;
                      return result;
                  }else if(start == nums[k]){
                      result[1] = k;
                      return result;
                  }
                  result[1] = j;
                  if(end == nums[k]){
                      result[0] = k;
                      return result;
                  }else if (end == nums[m]){
                      result[0] = m;
                      return result;
                  }
  
              }
          }
          return result;
      }
  

  3. 思路三（哈希表）空间思路O(n)

  public static int[] hashTable(int[] nums, int target){
          int[] result = {0,1};
          /* 理想状态，nums的长度为2，说明只有两个数所以可以直接返回 */
          if(nums.length == result.length){
              return result;
          }
         /* 通过存值匹配 */
          Map<Integer, Integer> hashTable = new HashMap<>();
          for (int i = 0; i < nums.length; i++) {
              if(hashTable.containsKey(target - nums[i])){
                  result[0] = hashTable.get(target - nums[i]);
                  result[1] = i;
                  return result;
              }
              hashTable.put(nums[i], i);
          }
          return new int[0];
      }