第一部分——哈希
哈希（Hash）：通俗来说，就是使用某种特定的方法（hash/散列函数）将输入的转化成一个特定的值<处理结果值可能相同，那就叫冲突>，这个值就相当于地址，在这个值对应存储相应的数据。
这样的键值对称作哈希表
常见的哈希算法有：
- MD5
- SHA2-256
特点：
- 相同的输入一定得到相同的输出；
- 不同的输入大概率得到不同的输出。
No.1 两数之和
给定一个整数数组
nums和一个整数目标值target，请你在该数组中找出 和为目标值target的那 两个 整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
一、暴力法（两个for走天下）
/**
* @param {number[]} nums
* @param {number} target
* @return {number[]}
*/
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)
return [i, j];
}
}
};
- 时间复杂度：O(n^2)
- 空间复杂度：O(1)
二、哈希表（推荐使用，效率更高）
1.两遍哈希表（两次迭代，一次在表中插入元素，一次对目标元素进行检查）
/**
* @param {number[]} nums
* @param {number} target
* @return {number[]}
*/
var twoSum = function(nums, target) {
var map = new Map();
for(var i = 0; i < nums.length; i ++){
map.set(nums[i], i);
}
for(var j = 0; j < nums.length; j++){
const flag = target - nums[j];
if(map.has(flag) && map.get(flag) !== j)
return [j,map.get(flag)];
}
console.log("no two sum");
};
- 时间复杂度：O(n)
- 空间复杂度：O(n)
2.一遍哈希表（迭代插入的同时进行目标元素的检查）
/**
* @param {number[]} nums
* @param {number} target
* @return {number[]}
*/
var twoSum = function(nums, target) {
// 构造哈希表
var map = new Map();
for (let i = 0; i < nums.length; i++) {
let complement = target - nums[i];
if (map.has(complement)) {
return [map.get(complement), i];
}
map.set(nums[i], i);
}
console.log("No two sum solution");
};
No.2字母异位词分组
/**
* @param {string[]} strs
* @return {string[][]}
*/
var groupAnagrams = function(strs) {
var map = new Map();
for (var s in strs) {
strs[s] = strs[s].split('').sort().join('');
if (map.has(strs[s])) {
map.get(str[s]).push(s);
}
else {
map.set(strs[s], [s]);
}
}
return Array.from(map.values());
};
本质还是查找问题，所以考虑使用哈希表：
观察异位词，也就是不同字母的排列顺序，那么只需要将字母按照某个顺序排列，然后进行匹配即可，相同顺序的就是异位词
最后返回哈希表的存储内容即可
No.128最长连续序列
/**
* @param {number[]} nums
* @return {number}
*/
var longestConsecutive = function(nums) {
var map = new Map();
var max = 0;
for (var n of nums) {
console.log(n);
if (!map.has(n)) {
var left = map.get(n - 1) || 0;
var right = map.get(n + 1) || 0;
var sum = left + right + 1;
map.set(n, sum);
max = Math.max(max, sum);
map.set(n - left, sum);
map.set(n + right, sum);
}
}
return max;
};
这道题最妙的一个点应该在于，常规的想法是枚举所有的元素，然后查找最长的连续长度，但是转换思想，当遍历一个元素时，我去求他左边的序列和右边的序列，如果能在哈希表里查到，那就正常，如果查不到，那就返回undefined，然后将 left、right 和当前元素 n 的长度相加并加1——len，这就是当前最长的序列，再将其和max进行取最大，不过要记得及时存入哈希表中，[num, len]
然后因为两端的left和right可能在之前就被访问过了，所以还要及时更新n-left和n+right的长度为len
值得注意的是：get获取的是当前序列对应的最大序列长度，也就是说，哈希表存放的实际上是每个序列对应的长度
