关于力扣第一题 两数之和（多方法）

题目描述：

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

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
1.穷举法，两次遍历，暴力计算。使用第1个数与后面的每个数之和判断是否等于目标值、再用第2个数字做同样的操作，直到完全相等，返回索引值+1：
  两个循环，时间复杂度为O(N*N)

var twoSum = function(nums, target) {
    for(var i = 0; i < nums.length - 1; i++){
        for(var j = i + 1; j < nums.length; j++) {
        if (nums[i] + nums[j] == target) {
            var arr = [];
            arr.push(i,j);
            return arr;
        }
      }
   }
};

2.利用indexOf, Array 的 indexOf 方法实际上是对数组再遍历一次，写法上有优化，但是实际时间复杂度还是O(N*N):

let twoSum = function(nums, target) {
    let a, b;
    for(let i = 0; i < nums.length; i++) {
        b = nums.indexOf(target - nums[i]);
        if(b > -1 && b !== i) {
            a = i;
            break;
        }
    }
    return [a, b];
};

3.使用对象索引（时间复杂度低）：

创建一个对象，并给它赋值，对象的键值是我们想要检索的值，对象的值是在数组中的索引。

解题思路：构造了arr{ key：value} 对象。将target-nums[i] 差值放在arr{ }对象中，并存储其位置i。然后每次就在arr{ }对象中找有没有对应的数即可。

var twoSum = function(nums, target) {
    var arr = {};
    for (var i = 0; i < nums.length; i++) {
        if (typeof(arr[nums[i]]) !== "undefined"){
            return [arr[nums[i]], i];                        
        }                         
        arr[target - nums[i]] = i;
    }
};

4.经典解题方法，排序+二分搜索

如果这个数据是有序的，那么我们很容易联想到使用二分搜索法,可以每次判断target-num[i]对应的值是否在num[i+1:]中，这个时候算法的复杂度变成了O(nlogn)。

var twoSum = function getSum(arr,sum) {
    if(arr == '' || arr.length == 0){
        return false;
    }
    // arr.sort((a,b) => { return a-b });  如果是无序数组可先转为有序数组再使用二分搜索法
    var left = 0, right = arr.length -1;
    while(left < right){
        if(arr[left] + arr[right] > sum){
            right--;
        }
        else if(arr[left] + arr[right] < sum){
            left++;
        }
        else{
            return [left,right]; 
            left++;
            right--;
        }
    }
}

5.Hash方法，在所给数组中查找依次查找与当前值所对应的目标值是否存在，如果存在则记录当前index值。

const twoSum = function(nums, target) {
   // 用于记录数组nums的长度
    const length = nums.length;
    // 实例化一个Map对象
    let hash = new Map();
    let index = 0;
    for (index = 0; index < length; index++) {
        // 设置 hashMap 的 <key, value>，用于后面比较取值
        hash.set(nums[index], index);
    }
 
 
    // 遍历数组中的每一个数，求出另一个与其相加可以满足条件的数的值，存储在 @param numToFind 中
    let numToFind;
    for( index = 0; index < length; index++) {
         numToFind = target - nums[index];
         // 查询 hashMap 中对应的值是否有对应的index，而且不能是当前数的下标（防止出现 3 + 3 = 6，但数组nums中只有一个3这样的情况）
         if (hash.has(numToFind) && index !== hash.get(numToFind)) {
              return [index, hash.get(numToFind)];
         }
     }
};