精选留言(15)

• 
  叶子

  2018-10-29

  set不允许重复。如果是数组是[3,3] target是6，则set是3，所以这里不能用set。

   1

   23
• 
  jevis

  2018-11-01

  因为set的无序 所以在获取第一个数的下标的时候会有问题，所以这里使用set不是很好，不过可以使用map，用来存储下标和数：
  
  public int[] twoSum(int[] nums, int target) {
          HashMap<Integer, Integer> map = new HashMap<>();
          int[] ans = new int[2];
          for (int i = 0; i < nums.length; i++) {
              int tt = target - nums[i];
              if (map.containsKey(nums[i])) {
                  ans[0] = map.get(nums[i]);
                  ans[1] = i;
              } else {
                  map.put(tt, i);
              }
          }
  
          return ans;
      }

  展开

  

   10
• 
  子青

  2018-10-27

  题目要求返回的是下标，用map好些吧，可以存储下标

  

   3
• 
  adream307

  2018-10-26

  对于每一个知识点，老师能否举个leetcode上hard的题，谢谢？

  

   3
• 
  缪文@场景鹿

  2018-12-25

  这个还可以更简单，用Map，key是9-x的值，value是x的下标，开始遍历前map是空的，遍历的同时判断，if（map.get（x)==null）｛map.put(i)} else return new int[]{i,map.get(x);
  o（n)的时间复杂度

  

   2
• 
  Geek_d7a810

  2018-12-17

  难道不是用map更好？
  go版本实现：
  func twoSum(arr []int, target int) [2]int{
      tmpMap := map[int]int{}
      for k, v := range arr{
          if index, ok := tmpMap[target-v]; ok{
              return [2]int{index, k}
          }
          tmpMap[v] = k
      }
      return [2]int{-1,-1}
  }

  展开

  

   1
• 
  努力的熊

  2019-10-10

  用Set不合适，改用map的话，key用来记录nums[i]的值，value用来记录对应的下标
  
  public int[] twoSum(int[] nums, int target) {
          int[] result = new int[2];
          Map<Integer,Integer> map = new HashMap<>();
          for (int i = 0; i < nums.length ; i++) {
              map.put(nums[i],i);
          }
          for (int i = 0; i < nums.length; i++) {
              int tmp = target - nums[i];
              if(map.containsKey(tmp)&&map.get(tmp)!=i){
                   result[0] = map.get(tmp);
                  result[1] = i;
              }
          }
          return result;
      }

  展开

  作者回复: Cool!

  

  
• 
  Toby

  2019-08-21

  private static int[] two_sum_method(int[] nums, int target) {
          Map<Integer, Integer> tempMap = new HashMap<Integer, Integer>();
          for (Integer i = 0; i < nums.length; i++) {
              if (tempMap.get(nums[i]) == null) {
                  tempMap.put(target-nums[i], i);
              } else {
                  return new int[]{i, tempMap.get(i)};
              }
          }
          return null;
      }

  展开

  作者回复: cool!

   1

  
• 
  🦁吴同

  2019-03-04

  用map 的前提是 不能出现重复的值，比如：{3,3}
  
  因为map 的k 存的是值，v 存的是下标。

  

  
• 
  海边的卡夫卡

  2019-02-15

  题目里的`exactly one solution`，导致解决的办法，有点粗暴，好比不需要考虑重复，因为重复元素，意味着多个解而已。只需要输出一个。即可。
  感觉还是要仔细读题，难度比easy更easy吧。

  

  
• 
  Aliliin

  2019-01-14

  PHP 暴力解法
  
  ```
  public function twoSum($nums, $target)
      {
          $outArr = [];
          foreach ($nums as $key => $num) {
              $num1 = $target - $num;
              foreach ($nums as $k => $n) {
                  if ($k != $key) {
                      if ($num1 == $n) {
                          $outArr = [
                              $key,
                              $k,
                          ];
                          if (!empty($outArr)) {
                              return $outArr;
                          }
                      }
                  }
  
              }
          }
          return $outArr;
      }
  ```

  展开

  

  
• 
  james

  2019-01-03

  这段代码用了快排，时间复杂度n*logn，但是在leetcode上运行比时间复杂度N的C++快，亲测过，原因是什么？
  public int[] twoSum(int[] nums, int target) {
           if(nums == null)
               return null;
           int[] nums2 = Arrays.copyOf(nums, nums.length);
           Arrays.sort(nums2);
           int a = 0, b = 0;
           int start = 0, end = nums2.length-1;
           //find two nums
           while(start<end){
               int sum = nums2[start] + nums2[end];
               if(sum < target)
                   start++;
               else if(sum > target)
                   end--;
               else{
                   a = nums2[start]; b = nums2[end];
                   break;
               }
           }
           //find the index of two numbers
           int[] res = new int[2];
           for(int i = 0; i < nums.length; i++){
               if(nums[i] == a){
                   res[0] = i;
                   break;
               }
           }
           if(a != b){
               for(int i = 0; i < nums.length; i++){
                   if(nums[i] == b){
                       res[1] = i;
                       break;
                   }
               }
           } else{
               for(int i = 0; i < nums.length; i++){
                   if(nums[i] == b && i != res[0]){
                       res[1] = i;
                       break;
                   }
               }
           }
           
           return res;
       }
  

  展开

  

  
• 
  yann [扬] :曹同学

  2018-11-15

  同样的代码,python3里面运行时间是python的3倍??

  作者回复: 可以大概是 leetcode 自己的问题。

  

  
• 
  Geek_45a079

  2018-10-28

  两个数求和，使用set是否存在些问题，因为set会去重复，同样的元素是指，下角标相同的不可重复使用。map更适用

  

  
• 
  FIMH

  2018-10-27

  老师，这里边应该用hashmap存入元素的值和其下标吧，因为结果要返回下标

  

  