LeetCode Scala 1. two sum 两数之和

解题思路

---

遍历法

简单来说就是两个for循环，嵌套起来
时间复杂度 O(n^2)，空间复杂度O(1)

object Solution {
  def twoSum(nums: Array[Int], target: Int): Array[Int] = {
    val res:Array[Int] = new Array[Int](2)
    for(i <- 0 until nums.length){
      for(j <- i+1 until nums.length){
        if(nums(i)+nums(j)==target){
          res(0)=i
          res(1)=j
        }
      }
    }
    res
    }
}

---

映射反向寻找法

简单来说就是应用map数据类型，使用map来完成数据查找的目的，里面；应用了哈希表的知识，这块我还没学，学了再把这里补上
这个的思路就是很简单的，用一个map来进行反向查找，查找每一个target-nums(i)值的index，如果这个值能够在map里找到，那就返回这两个就行了，这里要注意一个问题就是，在map中，如果对一个key赋两次值，那么前一次的赋值结果会被清除，这个是要注意的

import scala.collection.mutable.Map
object Solution {
    def twoSum(nums: Array[Int], target: Int): Array[Int] = {
      var map:Map[Int, Int] = Map[Int, Int]()
      val res:Array[Int] = new Array[Int](2)
      for(i <- 0 until nums.length){
        if(map.contains(target-nums(i))) {
          res(0)=map(target-nums(i))
          res(1)=i
        }
        map.put(nums(i), i)
      }
      res
    }
}

最后，我看了不少这道题的求解，发现大量的快速解法的方案都是用java写的，换句话说，在scala的环境里直接用java的组件来写，这样省去了大量的类型推断时间，进而节约了时间
最后贴一个leetcode上别的大佬的解法，感觉比我的解法节约的时间就在于大佬的算法在满足了要求以后就直接return了，进而节约了一些时间，所以效率更高

object Solution {
    def twoSum(nums: Array[Int], target: Int): Array[Int] = {
        val map = scala.collection.mutable.Map[Int, Int] ()
        var count = 0;
        for(num <- nums){
            val comp = target-num
            map.get(comp) match {
                case None => {map.put(num,count)}
                case Some(index) => return Array(index,count) 
            }
            count = count+1
        }
        Array(0,0)
    }
}

果然，在加上了这个return后，我的程序效率也一下子提升了不少