JavaScript算法题总结（五）哈希

/**
  * 
  * @param numbers int整型一维数组 
  * @param target int整型 
  * @return int整型一维数组
  */
function twoSum( numbers ,  target ) {
   const ans=new Array(2)
   let map=new Map();
    let n=numbers.length;
    for(let i=0;i<n;i++){
//         遍历一波 
//         看看map里面有没有与该值相加等于target的值 如果没有就把该值放到map里
        if(map.has(target-numbers[i])){
            ans[0]=map.get(target-numbers[i])+1;
            ans[1]=i+1;
            break
        }else{
            map.set(numbers[i],i)
        }
    }
    return ans
}
module.exports = {
    twoSum : twoSum
};

function MoreThanHalfNum_Solution(numbers)
{
    // write code here
    let map=new Map(),count;
    for(let i=0;i<numbers.length;i++){
        count=map.get(numbers[i])||0;
        map.set(numbers[i],count+1);
    }
    for(let i=0;i<numbers.length;i++){
        if(map.get(numbers[i])>numbers.length/2){
            return numbers[i];
        }
    }
}
module.exports = {
    MoreThanHalfNum_Solution : MoreThanHalfNum_Solution
};

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param array int整型一维数组 
 * @return int整型一维数组
 */
function FindNumsAppearOnce( array ) {
    // write code here
    let set=new Set();
    array=array.sort((a,b)=>(a-b))
    for(let i=0;i<array.length;i++){
        if(!set.has(array[i])){
            set.add(array[i]);
        }else{
            set.delete(array[i]);
        }
    }
   return [...set]
}
module.exports = {
    FindNumsAppearOnce : FindNumsAppearOnce
};

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param nums int整型一维数组 
 * @return int整型
 */
                
function minNumberDisappeared( nums ) {
  //结果要么是1-n  要么是n+1
  let set = new Set();
  nums.forEach(item=>set.add(item));
  
    //从1开始 
  for(let i=1; i<=nums.length; i++){
    if(!set.has(i))
      return i;
  }
  return nums.length+1;
}
module.exports = {
    minNumberDisappeared : minNumberDisappeared
};

module.exports = {
    minNumberDisappeared : minNumberDisappeared
};

var threeSum = function(nums) {
    // 对数组进行排序，如果nums[i]只要大于0。后面的数字都是大于0，就不存在三个数之和等于0的情况，帮助我们去重。
    nums.sort((a, b) => {
        return a - b;
    })
    let result = [];
    for(let i = 0; i < nums.length; i++) {
        // 固定nums[i]的值 查找是否有其他两个数字之和加上nums[i]等于0的
        if (nums[i] > 0) {
            return result;
        }
        // 跳过重复的值
        if (i != 0 && nums[i] === nums[i - 1]) {
            continue;
        }
        let left = i + 1;
        let right = nums.length - 1;
        // 利用此时的nums[i]，去找值符合的的其他两个数字
        while(left < right) {
            let sum = nums[i] + nums[left] + nums[right];
            if (sum == 0) {
                // 找到了符合条件的数字
                result.push([nums[i], nums[left], nums[right]]);
                // 已经找到符合条件的结果了，此时的left指针和right指针应该移动一个位置
                left++;
                right--;
                // 去重操作
                while(nums[left] === nums[left - 1]) {
                    left++;
                }
                while(nums[right] === nums[right + 1]) {
                    right--;
                }
            }
            if (sum > 0) {
                right--;
            }
            if(sum < 0) {
                left++;
            }
        }
    }
    return result;
};
module.exports = {
    threeSum : threeSum
};