1.哈希
1.两数之和
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
这是一个经典的两数之和问题，可以使用哈希表来解决。以下是一个JavaScript的实现：
function twoSum(nums, target) {
let 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);
}
return [];
}
在这个函数中，我们首先创建一个空的哈希表。然后，我们遍历输入数组的每个元素。对于每个元素，我们计算目标值与该元素的差（称为补数），然后检查哈希表中是否存在这个补数。如果存在，那么我们找到了两个和为目标值的数，返回它们的索引。如果不存在，我们将当前元素和它的索引添加到哈希表中。如果遍历完数组都没有找到两个和为目标值的数，我们返回一个空数组。
2.字母异位词分组
给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。
字母异位词 是由重新排列源单词的所有字母得到的一个新单词。
示例 1:
输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
这个问题可以通过使用哈希表来解决，将排序后的字符串作为键，原始字符串的列表作为值。以下是一个JavaScript的实现：
function groupAnagrams(strs) {
let map = new Map();
for (let str of strs) {
let sorted = [...str].sort().join('');
if (map.has(sorted)) {
map.get(sorted).push(str);
} else {
map.set(sorted, [str]);
}
}
return Array.from(map.values());
}
在这个函数中，我们首先创建一个空的哈希表。然后，我们遍历输入数组的每个字符串。对于每个字符串，我们将其字符排序并连接成一个新的字符串，然后检查哈希表中是否存在这个排序后的字符串。如果存在，我们将原始字符串添加到对应的列表中。如果不存在，我们在哈希表中添加一个新的条目，键是排序后的字符串，值是一个包含原始字符串的新列表。最后，我们返回哈希表中所有值的列表，这就是所有的字母异位词组。
3.最长连续序列
给定一个未排序的整数数组 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
提示：
0 <= nums.length <= 105
-109 <= nums[i] <= 109
这个问题可以通过使用哈希表来解决，哈希表中存储每个元素以及它所在的连续序列的长度。以下是一个JavaScript的实现：
function longestConsecutive(nums) {
let numSet = new Set(nums);
let longestStreak = 0;
for (let num of numSet) {
if (!numSet.has(num - 1)) {
let currentNum = num;
let currentStreak = 1;
while (numSet.has(currentNum + 1)) {
currentNum += 1;
currentStreak += 1;
}
longestStreak = Math.max(longestStreak, currentStreak);
}
}
return longestStreak;
}
在这个函数中，我们首先创建一个集合，包含输入数组中的所有元素。然后，我们遍历集合中的每个元素。对于每个元素，如果它的前一个元素不在集合中（也就是说，它是当前连续序列的第一个元素），我们就开始查找包含它的连续序列。我们通过不断地检查并增加当前元素，直到找不到下一个元素为止，同时我们也记录下当前连续序列的长度。最后，我们返回找到的最长连续序列的长度。
2.双指针
1.零移动
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
请注意 ，必须在不复制数组的情况下原地对数组进行操作。
示例 1:
输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]
示例 2:
输入: nums = [0]
输出: [0]
这个问题可以通过使用双指针来解决，一个指针用于遍历数组，另一个指针用于指向下一个非零元素应该放置的位置。以下是一个JavaScript的实现：
function moveZeroes(nums) {
let insertPos = 0;
for (let i = 0; i < nums.length; i++) {
if (nums[i] !== 0) {
nums[insertPos++] = nums[i];
}
}
while (insertPos < nums.length) {
nums[insertPos++] = 0;
}
}
在这个函数中，我们首先初始化一个指针insertPos为0，这个指针表示下一个非零元素应该放置的位置。然后，我们遍历数组，对于每个元素，如果它不是0，我们就将它放到insertPos指向的位置，然后将insertPos向前移动一位。这样，所有的非零元素都会被移到数组的前面，而且它们的相对顺序不会改变。最后，我们将insertPos之后的所有位置都填充为0，这样就完成了所有0的移动。
2.盛最多水的容器
给定一个长度为 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。
示例 2：
输入：height = [1,1]
输出：1
这个问题可以通过使用双指针来解决，一个指针从数组的开始位置开始移动，另一个指针从数组的结束位置开始移动。以下是一个JavaScript的实现：
function maxArea(height) {
let maxarea = 0, l = 0, r = height.length - 1;
while (l < r) {
maxarea = Math.max(maxarea, Math.min(height[l], height[r]) * (r - l));
if (height[l] < height[r])
l++;
else
r--;
}
return maxarea;
}
在这个函数中，我们首先初始化两个指针l和r，分别指向数组的开始位置和结束位置，然后初始化最大面积maxarea为0。然后，我们进入一个循环，只要l小于r，我们就继续循环。在每次循环中，我们计算当前两条线构成的容器的面积，如果这个面积大于maxarea，我们就更新maxarea。然后，我们将较短的那条线向中间移动一位，因为移动较长的线不会增加容器的面积，而移动较短的线可能会增加容器的面积。最后，我们返回maxarea，这就是容器可以储存的最大水量。
3.三数之和
给你一个整数数组 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 。
示例 3：
输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。
这个问题可以通过使用排序和双指针来解决。以下是一个JavaScript的实现：
function threeSum(nums) {
nums.sort((a, b) => a - b);
let result = [];
for (let i = 0; i < nums.length - 2; i++) {
if (i > 0 && nums[i] === nums[i - 1]) continue;
let j = i + 1, k = nums.length - 1;
while (j < k) {
let sum = nums[i] + nums[j] + nums[k];
if (sum === 0) {
result.push([nums[i], nums[j], nums[k]]);
while (nums[j] === nums[j + 1]) j++;
while (nums[k] === nums[k - 1]) k--;
j++;
k--;
} else if (sum < 0) {
j++;
} else {
k--;
}
}
}
return result;
}
在这个函数中，我们首先对数组进行排序。然后，我们遍历数组，对于每个元素，我们使用两个指针，一个指向它后面的元素，另一个指向数组的最后一个元素。然后，我们在两个指针之间查找两个数，使得这三个数的和为0。如果找到了，我们就将这三个数添加到结果中，然后移动两个指针，跳过所有重复的元素。如果这三个数的和小于0，我们就将前面的指针向后移动一位。如果这三个数的和大于0，我们就将后面的指针向前移动一位。最后，我们返回结果，这就是所有和为0的三元组。
4.接雨水
给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
示例 1：
输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。
示例 2：
输入：height = [4,2,0,3,2,5]
输出：9
这个问题可以使用双指针的方法来解决。以下是一个JavaScript的实现：
function trap(height) {
let left = 0, right = height.length - 1;
let maxLeft = 0, maxRight = 0;
let ans = 0;
while (left < right) {
if (height[left] < height[right]) {
height[left] >= maxLeft ? (maxLeft = height[left]) : ans += (maxLeft - height[left]);
++left;
}
else {
height[right] >= maxRight ? (maxRight = height[right]) : ans += (maxRight - height[right]);
--right;
}
}
return ans;
}
在这个函数中，我们首先初始化两个指针，一个在数组的开始，一个在数组的结束。然后，我们初始化两个变量，分别表示从左边和右边看到的最高的柱子。然后，我们在两个指针相遇之前，不断地移动指针。如果左边的柱子比右边的柱子低，我们就移动左边的指针，并更新左边的最高柱子。然后，我们将左边的最高柱子减去当前柱子的高度，就得到了这个位置可以接的雨水。如果右边的柱子比左边的柱子低，我们就做相反的操作。最后，我们返回接到的雨水的总量。
3.滑动窗口
1.无重复字符的最长字串
给定一个字符串 s ，请你找出其中不含有重复字符的 最长 子串 ****的长度。
示例 1:
输入: s = "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:
输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:
输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
这个问题可以使用滑动窗口的方法来解决。以下是一个JavaScript的实现：
function lengthOfLongestSubstring(s) {
let n = s.length;
let ans = 0;
let map = new Map(); // current index of character
// try to extend the range [i, j]
for (let j = 0, i = 0; j < n; j++) {
if (map.has(s.charAt(j))) {
i = Math.max(map.get(s.charAt(j)), i);
}
ans = Math.max(ans, j - i + 1);
map.set(s.charAt(j), j + 1);
}
return ans;
}
在这个函数中，我们使用一个Map来存储每个字符最后出现的位置。然后，我们使用两个指针表示字符串中的一段子串。我们不断地移动右指针，如果右指针指向的字符在Map中，我们就更新左指针的位置。然后，我们更新最长子串的长度。最后，我们返回最长子串的长度。
2.找到字符串中所有字母异位词
给定两个字符串 s 和 p，找到 s ****中所有 p ****的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。
异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。
示例 1:
输入: s = "cbaebabacd", p = "abc"
输出: [0,6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。
示例 2:
输入: s = "abab", p = "ab"
输出: [0,1,2]
解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的异位词。
这个问题可以使用滑动窗口的方法来解决。以下是一个JavaScript的实现：
function findAnagrams(s, p) {
let res = [];
let left = 0, right = 0;
let needs = {}, window = {};
let match = 0;
for (let i = 0; i < p.length; i++) {
needs[p[i]] ? needs[p[i]]++ : needs[p[i]] = 1;
}
let needsLen = Object.keys(needs).length;
while (right < s.length) {
let c1 = s[right];
if (needs[c1]) {
window[c1] ? window[c1]++ : window[c1] = 1;
if (window[c1] === needs[c1]) {
match++;
}
}
right++;
while (match === needsLen) {
if (right - left === p.length) {
res.push(left);
}
let c2 = s[left];
if (needs[c2]) {
window[c2]--;
if (window[c2] < needs[c2]) {
match--;
}
}
left++;
}
}
return res;
}
在这个函数中，我们首先初始化一个滑动窗口和两个哈希表，一个用于记录p中的字符和出现的次数，一个用于记录当前窗口中的字符和出现的次数。然后，我们不断地移动右指针，如果右指针指向的字符在p中，我们就更新窗口中的记录。如果窗口中的某个字符的出现次数和p中的相同，我们就更新匹配的字符数。当匹配的字符数和p中的字符种类数相同，我们就找到了一个异位词。然后，我们就可以开始移动左指针，缩小窗口。最后，我们返回所有找到的异位词的起始位置。
4.子串
1.和为k的子数组
给你一个整数数组 nums 和一个整数 k ，请你统计并返回 该数组中和为 k ******的子数组的个数 。
子数组是数组中元素的连续非空序列。
示例 1：
输入：nums = [1,1,1], k = 2
输出：2
示例 2：
输入：nums = [1,2,3], k = 3
输出：2
这个问题可以使用哈希表来解决。以下是一个JavaScript的实现：
function subarraySum(nums, k) {
let count = 0, sum = 0;
let map = new Map();
map.set(0, 1); // sum为0的子数组有一个（空数组）
for (let i = 0; i < nums.length; i++) {
sum += nums[i];
if (map.has(sum - k)) {
count += map.get(sum - k);
}
map.set(sum, (map.get(sum) || 0) + 1);
}
return count;
}
在这个函数中，我们首先初始化一个哈希表，用于记录前缀和以及对应的个数。然后，我们遍历数组，不断地更新前缀和。如果当前的前缀和减去k在哈希表中，我们就找到了一个和为k的子数组。然后，我们更新哈希表中前缀和的个数。最后，我们返回找到的和为k的子数组的个数。
2.滑动窗口的最大值
给你一个整数数组 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]
这个问题可以使用双端队列来解决。以下是一个JavaScript的实现：
function maxSlidingWindow(nums, k) {
let deque = []; // store indices
let result = [];
for (let i = 0; i < nums.length; i++) {
while (deque.length && nums[deque[deque.length - 1]] < nums[i]) {
deque.pop();
}
deque.push(i);
if (deque[0] === i - k) {
deque.shift();
}
if (i >= k - 1) {
result.push(nums[deque[0]]);
}
}
return result;
}
在这个函数中，我们首先初始化一个双端队列和一个结果数组。然后，我们遍历数组，对于每个元素，我们首先从队列的后面删除所有小于当前元素的元素，然后将当前元素的索引加入队列。如果队列的第一个元素是滑动窗口之外的元素，我们就将其删除。如果我们已经遍历了k个元素，我们就将队列的第一个元素加入结果数组。最后，我们返回结果数组。
3.最小覆盖子串
给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。
注意：
- 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
- 如果 s 中存在这样的子串，我们保证它是唯一的答案。
示例 1：
输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"
解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。
示例 2：
输入：s = "a", t = "a"
输出："a"
解释：整个字符串 s 是最小覆盖子串。
示例 3:
输入: s = "a", t = "aa"
输出: ""
解释: t 中两个字符 'a' 均应包含在 s 的子串中，
因此没有符合条件的子字符串，返回空字符串。
这个问题可以使用滑动窗口的方法来解决。以下是一个JavaScript的实现：
function minWindow(s, t) {
let minLen = Infinity;
let start = 0;
let map = {};
let missingType = 0;
for (let i = 0; i < t.length; i++) {
if (!map[t[i]]) {
missingType++;
map[t[i]] = 1;
} else {
map[t[i]]++;
}
}
let l = 0, r = 0;
for (; r < s.length; r++) {
let rightChar = s[r];
if (map[rightChar] !== undefined) map[rightChar]--;
if (map[rightChar] === 0) missingType--;
while (missingType === 0) {
if (r - l + 1 < minLen) {
minLen = r - l + 1;
start = l;
}
let leftChar = s[l];
if (map[leftChar] !== undefined) map[leftChar]++;
if (map[leftChar] > 0) missingType++;
l++;
}
}
if (minLen === Infinity) return "";
return s.substring(start, start + minLen);
}
在这个函数中，我们首先初始化一个哈希表，用于记录t中的字符和出现的次数。然后，我们使用两个指针表示字符串中的一段子串。我们不断地移动右指针，如果右指针指向的字符在t中，我们就更新哈希表中的记录。如果哈希表中的某个字符的出现次数为0，我们就找到了一个包含t的子串。然后，我们就可以开始移动左指针，缩小子串。最后，我们返回最小的包含t的子串。
5.普通数组
1.最大子数组和
给你一个整数数组 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
/**
* @param {number[]} nums
* @return {number}
*/
var maxSubArray = function(nums) {
let dp = Array(nums.length);
dp[0] = nums[0];
let max = dp[0];
for (let i = 1; i < nums.length; i++) {
dp[i] = nums[i] + (dp[i - 1] > 0 ? dp[i - 1] : 0);
max = Math.max(max, dp[i]);
}
return max;
};
2.合并区间
以数组 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] 可被视为重叠区间。
/**
* @param {number[][]} intervals
* @return {number[][]}
*/
var merge = function(intervals) {
if (!intervals.length) return intervals;
intervals.sort((a, b) => a[0] - b[0]);
let prev = intervals[0];
let res = [prev];
for (let curr of intervals) {
if (curr[0] <= prev[1]) {
prev[1] = Math.max(prev[1], curr[1]);
} else {
res.push(curr);
prev = curr;
}
}
return res;
};
3.轮转数组
给定一个整数数组 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]
/**
* @param {number[]} nums
* @param {number} k
* @return {void} Do not return anything, modify nums in-place instead.
*/
var rotate = function(nums, k) {
k = k % nums.length;
reverse(nums, 0, nums.length - 1);
reverse(nums, 0, k - 1);
reverse(nums, k, nums.length - 1);
};
function reverse(nums, start, end) {
while (start < end) {
let temp = nums[start];
nums[start] = nums[end];
nums[end] = temp;
start++;
end--;
}
}
4.除自身以外数组的乘积
给你一个整数数组 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]
/**
* @param {number[]} nums
* @return {number[]}
*/
var productExceptSelf = function(nums) {
let length = nums.length;
let answer = Array(length);
answer[0] = 1;
for (let i = 1; i < length; i++) {
answer[i] = nums[i - 1] * answer[i - 1];
}
let R = 1;
for (let i = length - 1; i >= 0; i--) {
answer[i] = answer[i] * R;
R *= nums[i];
}
return answer;
};
5.缺失的第一个正数
给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。
请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。
示例 1：
输入：nums = [1,2,0]
输出：3
解释：范围 [1,2] 中的数字都在数组中。
示例 2：
输入：nums = [3,4,-1,1]
输出：2
解释：1 在数组中，但 2 没有。
示例 3：
输入：nums = [7,8,9,11,12]
输出：1
解释：最小的正数 1 没有出现。
/**
* @param {number[]} nums
* @return {number}
*/
var firstMissingPositive = function(nums) {
let n = nums.length;
for (let i = 0; i < n; i++) {
while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] != nums[i]) {
[nums[nums[i] - 1], nums[i]] = [nums[i], nums[nums[i] - 1]];
}
}
for (let i = 0; i < n; i++) {
if (nums[i] != i + 1) {
return i + 1;
}
}
return n + 1;
};
6.矩阵
1.矩阵置零
给定一个 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]]
/**
* @param {number[][]} matrix
* @return {void} Do not return anything, modify matrix in-place instead.
*/
var setZeroes = function(matrix) {
let m = matrix.length, n = matrix[0].length;
let flagCol0 = false, flagRow0 = false;
for (let i = 0; i < m; i++) {
if (matrix[i][0] == 0) {
flagCol0 = true;
}
}
for (let j = 0; j < n; j++) {
if (matrix[0][j] == 0) {
flagRow0 = true;
}
}
for (let i = 1; i < m; i++) {
for (let j = 1; j < n; j++) {
if (matrix[i][j] == 0) {
matrix[i][0] = matrix[0][j] = 0;
}
}
}
for (let i = 1; i < m; i++) {
for (let j = 1; j < n; j++) {
if (matrix[i][0] == 0 || matrix[0][j] == 0) {
matrix[i][j] = 0;
}
}
}
if (flagCol0) {
for (let i = 0; i < m; i++) {
matrix[i][0] = 0;
}
}
if (flagRow0) {
for (let j = 0; j < n; j++) {
matrix[0][j] = 0;
}
}
};
2.螺旋矩阵
给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。
示例 1：
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]
示例 2：
输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]
/**
* @param {number[][]} matrix
* @return {number[]}
*/
var spiralOrder = function(matrix) {
if (!matrix.length || !matrix[0].length) {
return [];
}
const rows = matrix.length, columns = matrix[0].length;
const visited = Array.from(new Array(rows), () => new Array(columns).fill(false));
const total = rows * columns;
const order = new Array(total).fill(0);
let directionIndex = 0, row = 0, column = 0;
const directions = [[0, 1], [1, 0], [0, -1], [-1, 0]]; // 右下左上
for (let i = 0; i < total; i++) {
order[i] = matrix[row][column];
visited[row][column] = true;
const nextRow = row + directions[directionIndex][0], nextColumn = column + directions[directionIndex][1];
if (!(0 <= nextRow && nextRow < rows && 0 <= nextColumn && nextColumn < columns && !(visited[nextRow][nextColumn]))) {
directionIndex = (directionIndex + 1) % 4;
}
row += directions[directionIndex][0];
column += directions[directionIndex][1];
}
return order;
};
3.旋转图像
给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。
你必须在原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 ****使用另一个矩阵来旋转图像。
示例 1：
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[[7,4,1],[8,5,2],[9,6,3]]
示例 2：
输入：matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
输出：[[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]
/**
* @param {number[][]} matrix
* @return {void} Do not return anything, modify matrix in-place instead.
*/
var rotate = function(matrix) {
const n = matrix.length;
for (let i = 0; i < n; i++) {
for (let j = i; j < n; j++) {
[matrix[i][j], matrix[j][i]] = [matrix[j][i], matrix[i][j]];
}
}
for (let i = 0; i < n; i++) {
matrix[i].reverse();
}
};
4.搜索二维矩阵 II
编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性：
- 每行的元素从左到右升序排列。
- 每列的元素从上到下升序排列。
示例 1：
输入：matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 5
输出：true
示例 2：
输入：matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 20
输出：false
/**
* @param {number[][]} matrix
* @param {number} target
* @return {boolean}
*/
var searchMatrix = function(matrix, target) {
if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
return false;
}
let row = 0;
let col = matrix[0].length - 1;
while (row < matrix.length && col >= 0) {
if (matrix[row][col] == target) {
return true;
} else if (matrix[row][col] > target) {
col--;
} else {
row++;
}
}
return false;
};
