不够优秀，发量尚多，千锤百炼，方可成佛。为了准备春招，我准备把热题100的给大家写一下，这个样的话我可以复习和巩固一下。话不多说直接开始，
1. 两数之和
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。
你可以按任意顺序返回答案。
示例 1：
输入： nums = [2,7,11,15], target = 9
输出： [0,1]
解释： 因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：
输入： nums = [3,2,4], target = 6
输出： [1,2]
答案如下
ar twoSum = function(nums, target){
let prevNums = {} ; // 存储出现过的数字，和对应的索引
for (let i = 0; i < nums.length; i++) { // 遍历元素
const curNum = nums[i]; // 当前元素
const targetNum = target - curNum; // 满足要求的目标元素
const targetNumIndex = prevNums[targetNum]; // 在prevNums中获取目标元素的索引
if (targetNumIndex !== undefined) { // 如果存在，直接返回 [目标元素的索引,当前索引]
return [targetNumIndex, i];
} else { // 如果不存在，说明之前没出现过目标元素
prevNums[curNum] = i; // 存入当前的元素和对应的索引
}
}
}
49. 字母异位词分组
给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。
字母异位词 是由重新排列源单词的所有字母得到的一个新单词。
示例 1:
输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
示例 2:
输入: strs = [""]
输出: [[""]]
示例 3:
输入: strs = ["a"]
输出: [["a"]]
答案如下
let res = {};
for (let i = 0; i < strs.length; i++) {
let a = [...strs[i]].sort().join('');
if (res[a]) {
res[a].push(strs[i]);
} else {
res[a] = [strs[i]];
}
}
return Object.values(res);
128. 最长连续序列
给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。
请你设计并实现时间复杂度为 O(n) **的算法解决此问题。
示例 1：
输入： nums = [100,4,200,1,3,2]
输出： 4
解释： 最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。
示例 2：
输入： nums = [0,3,7,2,5,8,4,6,0,1]
输出： 9
答案如下
var longestConsecutive = function(nums) {
let max = 0;
let set = new Set(nums);
for (let item of set) {
// 只有当 item-1 不在集合中时，才开始新的序列
if (!set.has(item - 1)) {
let a = item;
let b = 1;
// 继续寻找下一个连续的数字
while (set.has(a + 1)) {
b++;
a++;
}
// 更新最大长度
max = Math.max(b, max);
}
}
return max;
};
283. 移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
请注意 ，必须在不复制数组的情况下原地对数组进行操作。
示例 1:
输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]
示例 2:
输入: nums = [0]
输出: [0]
答案如下
var moveZeroes = function(nums) {
let lastNonZeroFoundAt = 0;
// 如果当前元素不是 0，就把它放到最后一个非零元素的位置
for (let i = 0; i < nums.length; i++) {
if (nums[i] !== 0) {
nums[lastNonZeroFoundAt] = nums[i];
lastNonZeroFoundAt++;
}
}
// 将剩下的位置全部填充为 0
for (let i = lastNonZeroFoundAt; i < nums.length; i++) {
nums[i] = 0;
}
return nums;
};
11. 盛最多水的容器
给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。
找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
返回容器可以储存的最大水量。
说明： 你不能倾斜容器。
示例 1：
输入： [1,8,6,2,5,4,8,3,7]
输出： 49
解释： 图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
答案如下
var maxArea = function(height) {
let max = 0;
let left = 0;
let right = height.length - 1;
while(left < right){
const long = Math.min(height[left], height[right]);
max = Math.max(max, (right - left) * long);
if (height[left] < height[right]) {
left++;
} else {
right--;
}
}
return max
};
代码
测试用例
测试用例
测试结果
15. 三数之和
给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。
注意： 答案中不可以包含重复的三元组。
示例 1：
输入： nums = [-1,0,1,2,-1,-4]
输出： [[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。
示例 2：
输入： nums = [0,1,1]
输出： []
解释： 唯一可能的三元组和不为 0 。
var threeSum = function(nums) {
let res = [];
nums.sort((a, b) => a - b);
for (let i = 0; i < nums.length - 2; i++) {
if (nums[i] > 0) break; // 如果当前数字大于0，则三数之和不可能为0
if (i > 0 && nums[i] === nums[i - 1]) continue; // 跳过重复的数字
let l = i + 1;
let r = nums.length - 1;
while (l < r) {
const sum = nums[i] + nums[l] + nums[r];
if (sum === 0) {
res.push([nums[i], nums[l], nums[r]]);
while (l < r && nums[l] === nums[l + 1]) l++; // 跳过重复的数字
while (l < r && nums[r] === nums[r - 1]) r--; // 跳过重复的数字
l++;
r--;
} else if (sum < 0) {
l++; // 如果和小于0，移动左指针以增加和
} else {
r--; // 如果和大于0，移动右指针以减少和
}
}
}
return res;
}
3. 无重复字符的最长子串
给定一个字符串 s ，请你找出其中不含有重复字符的 **最长 **
子串
****的长度。
示例 1:
输入: s = "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:
输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:
输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列， 不是子串。
代码如下
var lengthOfLongestSubstring = function(s) {
let max = 0 ;
let res = [] ;
for(let i = 0 ; i < s.length ; i++){
while(res.includes(s[i])) res.shift()
res.push(s[i])
max = Math.max( max , res.length)
}
return max
};
5. 最长回文子串
给你一个字符串 s，找到 s 中最长的
回文
子串
。
示例 1：
输入： s = "babad"
输出： "bab"
解释： "aba" 同样是符合题意的答案。
示例 2：
输入： s = "cbbd"
输出： "bb"
答案如下
let max = ''
function helper(l,r){
while(l >= 0 && r<s.length && s[l] === s[r]){
l--;
r++;
}
const maxStr = s.slice(l + 1, r + 1 - 1);
// 取最大长度的回文字符
if (maxStr.length > max.length) max = maxStr
}
for(let i=0; i< s.length; i++) {
// 分奇偶， 一次遍历，每个字符位置都可能存在奇数或偶数回文
helper(i, i)
helper(i, i+1)
}
return max
239. 滑动窗口最大值
给你一个整数数组 nums，有一个大小为 k **的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
返回 滑动窗口中的最大值 。
示例 1：
输入： nums = [1,3,-1,-3,5,3,6,7], k = 3
输出： [3,3,5,5,6,7]
解释：
滑动窗口的位置 最大值
--------------- -----
[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7
示例 2：
输入： nums = [1], k = 1
输出： [1]
答案如下
let res = [];
for (let i = 0; i <= nums.length - k; i++) {
const arr = nums.slice(i, i + k);
arr.sort((a, b) => a - b);
res.push(arr[arr.length - 1]);
}
return res;
这种方法是比较传统，有些案例过不了
let res = []
let q =[]
for (let i = 0 ; i < nums.length ; i++){
while( q.length > 0 && nums[i]>nums[q.at(-1)]) q.pop()
q.push(i)
if(i-q[0]>= k) q.shift()
if(i>=k-1) res.push(nums[q[0]])
}
return res
这个是单调递减栈的方法
53. 最大子数组和
给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
子数组
是数组中的一个连续部分。
示例 1：
输入： nums = [-2,1,-3,4,-1,2,1,-5,4]
输出： 6
解释： 连续子数组 [4,-1,2,1] 的和最大，为 6 。
示例 2：
输入： nums = [1]
输出： 1
示例 3：
输入： nums = [5,4,-1,7,8]
输出： 23
答案如下
let pre = 0, maxAns = nums[0];
nums.forEach((x) => {
pre = Math.max(pre + x, x);
maxAns = Math.max(maxAns, pre);
});
return maxAns;
代码
测试用例
测试用例
测试结果
56. 合并区间
以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。
示例 1：
输入： intervals = [[1,3],[2,6],[8,10],[15,18]]
输出： [[1,6],[8,10],[15,18]]
解释： 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
示例 2：
输入： intervals = [[1,4],[4,5]]
输出： [[1,5]]
解释： 区间 [1,4] 和 [4,5] 可被视为重叠区间。
答案如下
var merge = function(intervals) {
intervals.sort((a,b)=> a[0] - b[0])
let res = [intervals[0]];
for(let i = 0 ; i < intervals.length ; i++){
if(res[res.length - 1][1] >= intervals[i][0] ){
res[res.length - 1]=[res[res.length - 1][0],Math.max(res[res.length - 1][1],intervals[i][1])]
}else{
res.push(intervals[i])
}
}
return res
};
189. 轮转数组
给定一个整数数组 nums，将数组中的元素向右轮转 k **个位置，其中 k **是非负数。
示例 1:
输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右轮转 1 步: [7,1,2,3,4,5,6]
向右轮转 2 步: [6,7,1,2,3,4,5]
向右轮转 3 步: [5,6,7,1,2,3,4]
示例 2:
输入： nums = [-1,-100,3,99], k = 2
输出： [3,99,-1,-100]
解释:
向右轮转 1 步: [99,-1,-100,3]
向右轮转 2 步: [3,99,-1,-100]
let num = []
while(i>0){
let arr1 = nums.pop()
nums.unshift(arr1)
i--
}
return nums
这个方法有个案例不能通过
var rotate = function(nums, k) {
k = k % nums.length; // 处理k大于数组长度的情况
nums.unshift(...nums.splice(nums.length - k, k));
};
这个方法最简单，而且能理解
238. 除自身以外数组的乘积
给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积 。
题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内。
请 不要使用除法， 且在 O(n) 时间复杂度内完成此题。
示例 1:
输入: nums = [1,2,3,4]
输出: [24,12,8,6]
示例 2:
输入: nums = [-1,1,0,-3,3]
输出: [0,0,9,0,0]
var productExceptSelf = function(nums) {
const length = nums.length;
const output = new Array(length).fill(1);
// 从左到右计算前缀乘积
let prefix = 1;
for (let i = 0; i < length; i++) {
output[i] = prefix;
prefix *= nums[i];
}
// 从右到左计算后缀乘积，并与前缀乘积相乘
let suffix = 1;
for (let i = length - 1; i >= 0; i--) {
output[i] *= suffix;
suffix *= nums[i];
}
return output;
};
73. 矩阵置零
给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地 算法 。
示例 1：
输入： matrix = [[1,1,1],[1,0,1],[1,1,1]]
输出： [[1,0,1],[0,0,0],[1,0,1]]
示例 2：
输入： matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
输出： [[0,0,0,0],[0,4,5,0],[0,3,1,0]]
var setZeroes = function(matrix) {
let h = matrix[0].length
let s = matrix.length;
let hArr = new Array(h).fill(0);
let sArr = new Array(s).fill(0);
for(let i = 0 ; i < s ;i++){
for(let j = 0 ; j< h ;j++){
if( matrix[i][j] === 0 ){
hArr[i] = 1;
sArr[j] = 1
}
}
}
for(let i = 0 ; i < s ;i++){
for(let j = 0 ; j< h ;j++){
if(hArr[i] === 1 || sArr[j] === 1 ){
matrix[i][j] = 0
}
}
}
};
相交链表
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。
图示两个链表在节点 c1 开始相交 ：
题目数据 保证 整个链式结构中不存在环。
var getIntersectionNode = function(headA, headB) {
let set = new Set();
while(headA){
set.add(headA)
headA = headA.next;
}
while(headB){
if(set.has(headB)){
return headB
}
headB = headB.next
}
};
