-
数组
-
二分查找：
-
704. 二分查找
-
-
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
class Solution {
public int search(int[] nums, int target) {
// 避免当 target 小于nums[0] nums[nums.length - 1]时多次循环运算
if (target < nums[0] || target > nums[nums.length - 1]) {
return -1;
}
int left = 0, right = nums.length - 1;
// 不断缩小 left 与 right 之间的距离 当left >= right时表示没有找到相匹配的元素
while (left <= right) {
int mid = left + ((right - left) / 2); // 因此为有序数组折中比较元素 判断目标值大概位置
if (nums[mid] == target)
return mid;
else if (nums[mid] < target) // 目标值在右侧
left = mid + 1;
else if (nums[mid] > target) // 目标值在左侧
right = mid - 1;
}
return -1;
}
}-
-
-
35.搜索插入位置
-
-
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
class Solution {
public int searchInsert(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
// 不断缩小 left 与 right 之间的距离 当left >= right时表示没有找到相匹配的元素
while (left <= right) {
int middle = left + ((right - left) / 2); // 因此为有序数组折中比较元素 判断目标值大概位置
if (nums[middle] < target) { // 目标值在右侧
left = middle + 1;
} else if (nums[middle] > target) { // 目标值在左侧
right = middle -1 ;
} else {
return middle;
}
}
return left; // 目标值不在数组中 返回将会被插入的位置
}
}-
-
-
34.在排序数组中查找元素的第一个和最后一个位置
-
-
给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target，返回 [-1, -1]
// 先二分查找目标值位置 根据返回的下标不断向两侧再次寻找目标值 找出给定目标值在数组中的开始位置和结束位置 无则返回 [-1, -1]
// 先二分查找目标值位置 根据返回的下标不断向两侧再次寻找目标值 找出给定目标值在数组中的开始位置和结束位置 无则返回 [-1, -1]
class Solution {
public int[] searchRange(int[] nums, int target) {
int index = binarySearch(nums, target);
// 无目标值
if (index == -1) {
return new int[]{-1,-1};
}
int left = index;
int right = index;
// 向左侧寻找开始位置
while(left - 1 >= 0 && nums[left - 1] == target) {
left--;
}
// 向右侧寻找结束位置
while(right + 1 < nums.length && (nums[right + 1] == target)) {
right++;
}
return new int[]{left, right};
}
// 二分查找目标值位置
public int binarySearch(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
while (left <= right) {
int middle = left + ((right - left) >> 1);
if (nums[middle] > target) {
right = middle - 1;
} else if (nums[middle] < target) {
left = middle + 1;
} else {
return middle;
}
}
return -1;
}
}-
-
-
69.x 的平方根
-
-
给你一个非负整数 x ，计算并返回 x 的 算术平方根 。由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。
class Solution {
public int mySqrt(int x) {
if (x == 0) {
return 0; // 特殊值直接返回其结果
}
if (x == 1) {
return 1; // 特殊值直接返回其结果
}
int letf = 0;
int rigth = x;
// 利用二分特性寻找平方根
while (letf <= rigth) {
int middle = letf + ((rigth - letf) / 2);
if (middle < x / middle) { // 相当于 middle*middle < x 则平方根在middle右侧 继续寻找
letf = middle + 1;
} else if (middle > x / middle) { // 相当于 middle*middle > x 则平方根在middle左侧 继续寻找
rigth = middle - 1;
} else {
return middle; // 相当于 middle*middle == x 则找到平方根
}
}
return rigth; // 未找到 middle*middle == x 但近似值为 rigth
}
}-
-
-
367.有效的完全平方数
-
-
给定一个 正整数 num ，编写一个函数，如果 num 是一个完全平方数，则返回 true ，否则返回 false 。
// 根据二分查找不断找中间值 判断其平方是否等于num 直到前指针 >= 后指针 则表示num不能完全开平方
// 根据二分查找不断找中间值 判断其平方是否等于num 直到前指针 >= 后指针 则表示num不能完全开平方
class Solution {
public boolean isPerfectSquare(int num) {
int letf = 1;
int rigth = num;
// 二分查找不断找中间值
while (letf <= rigth) {
int middle = letf + ((rigth - letf) / 2); // 中间值
if (middle == num / middle) { // 相当于 middle*middle == num 则是有效的完全平方数
if(num % middle == 0) { // 再次判断减少误差
return true;
}
letf = middle + 1;
} else if (middle > num / middle) { // 相当于 middle*middle > num 则平方根在middle左侧 继续寻找
rigth = middle - 1;
} else { // 相当于 middle*middle < num 则平方根在middle右侧 继续寻找
letf = middle + 1;
}
}
return false;
}
}-
-
移除元素
-
27.移除元素
-
-
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
// 不是有序数组则可以将目标值都移至数组最后面 两个指针 一个最前 一个最后
class Solution {
public int removeElement(int[] nums, int val) {
int j = nums.length - 1; // 目标值将要放置的位置
for (int i = 0; i <= j; i++) {
if(nums[i] == val) { // 找到目标值
samp(nums, i--, j--); // 将目标值移至到数组后方 同时 j-- 下个目标值将要放置的位置 i-- 预防换过来的值也是目标值 for有i++ 即i保持不动
}
}
return j + 1; // 返回移除后数组的新长度
}
void samp(int[] nums, int i, int j) { // 互换两个元素的位置
int temp = nums[j];
nums[j] = nums[i];
nums[i] = temp;
}
}-
-
-
26.删除排序数组中的重复项
-
-
给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致
由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。
将最终结果插入 nums 的前 k 个位置后返回 k 。
不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成
// 只要遇到两个不相等的值就将其移动 又因为其是有序数组 前后的移动不会改变其有序状态
class Solution {
public int removeDuplicates(int[] nums) {
int q = 0; // 前指针
int p = 1; // 后指针
while (p < nums.length) { // 遍历完整个数组
if (nums[q] != nums[p]) { // 当两个值相等时前指针不动 后指针往下移 直到遇到不相等时就将元素移过来
nums[++q] = nums[p]; // 当两个值不相等时将后元素移至前元素后面
}
p++;
}
return q + 1; // 新数组的长度
}
}-
-
-
283.移动零
-
-
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
// 一个前指针 一个后指针 当后指针遇到不等于 0 的元素时就将往前指针上挪
class Solution {
public void moveZeroes(int[] nums) {
int j = 0;
for (int i = 0; i < nums.length; i++) { // 后指针 遍历数组元素
if (nums[i] != 0) { // 当不等于 0 时就将其元素往前指针上挪
int temp = nums[i];
nums[i] = nums[j];
nums[j++] = temp; // 挪完以后j++ 准备接收下一个不等于 0 的元素
}
}
}
}-
-
-
844.比较含退格的字符串
-
-
给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。
// 例如有两个字符串 ABC#E ABC#E
// 各有一个指针 记录倒序遍历下标 一个存储位 存储#的数量 即>0时表示可以消除字符
// #代表退格字符 所以#只会将#前面的字符清除 可以倒序遍历字符串 遇到#时记录 再遇到字符时消除（前提#的数量>0）
// 将#该记录的记录 该消除的消除处 再判断两个指针位置的字符是否相同 不相同则不是相同的字符串 相同则指针--继续往前遍历判断 直到遍历完字符串
// 两个指针都必须同时大于0 否则则是表明一个字符串长一个字符串短 这也不是相同的字符串
class Solution {
public boolean backspaceCompare(String s, String t) {
int i = s.length() - 1; // s字符串指针
int j = t.length() - 1; // t字符串指针
int ss = 0; // s字符串#数量 即可消除元素的个数
int tt = 0; // t字符串#数量 即可消除元素的个数
while (i >= 0 || j >= 0) { // 遍历完两个字符串
while (i >= 0) { // 先对s字符串进行判断处理#
if (s.charAt(i) == '#') { // 遇到#
ss++; // 记录#数量 ++
i--; // 指针往前移
} else if (ss > 0) { // #数量大于 0 即可以消除此字符
ss--; // 记录#数量 --
i--; // 指针往前移
} else {
break; // 则没有可消除的元素 需要比较两个指针位置字符
}
}
while (j >= 0) { // 同上
if (t.charAt(j) == '#') {
tt++;
j--;
} else if (tt > 0) {
tt--;
j--;
} else {
break;
}
}
if (i >= 0 && j >= 0) { // 两个指针同时 >= 0
if(s.charAt(i) != t.charAt(j)) { // 如果两个指针处的字符不相等 则直接结束 两个字符串不相同
return false;
}
} else { // 或两个指针不能同时满足 >= 0 可能都遍历完成 或 一长一短
if (i >=0 || j >= 0) { // 一长一短 判断 其中一个指针出现 -1 而另一个 >= 0 则表明是一长一短
return false;
}
}
i--; // 指针往前移
j--;
}
return true; // 两个字符串相同
}
}-
-
-
977.有序数组的平方
-
-
给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
class Solution {
public int[] sortedSquares(int[] nums) {
int[] num = new int[nums.length]; // 定义新数组 与原数组长度相等
int numindex = num.length - 1; // 新数组指针 放较大平方数
int letf = 0; // 原数组前指针
int rigth = nums.length - 1; // 原数组后指针
while (letf <= rigth) { // 遍历完原数组
if (Math.abs(nums[letf]) > Math.abs(nums[rigth])) { // 判断绝对值大小 即判断平方后大小
num[numindex] = nums[letf] * nums[letf]; // 将较大平方放置新数组后面
numindex --;
letf ++;
} else {
num[numindex] = nums[rigth] * nums[rigth]; // 将较大平方放置新数组后面
numindex --;
rigth --;
}
}
return num; // 返回新数组
}
}-
-
长度最小的子数组
-
209.长度最小的子数组
-
-
给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
// 使用滑动窗口 两个指针 一前letf 一后rigth 一个记录长度result 一个相加结果sum
// 例如： [2,3,1,2,4,3] target=7
// 最初两个都指0 不断移动后指针rigth 并且不断相加 sum += nums[rigth]
// 当sum >= target时记录result长度 并取 result 与 rigth-letf+1（当前长度） 当中最短的数值
// 记录完成后移动前指针 并sum -= nums[letf]; letf++; 再次判断sum是否还大于target 大于侧再次记录其长度 继续移动前指针 当不再大于时移动后指针rigth 直到遍历完数组 result记录1最短长度
class Solution {
public int minSubArrayLen(int target, int[] nums) {
int letf = 0; // 前指针
int sum = 0; // 相加结果
int result = Integer.MAX_VALUE; // 记录最短长度
for (int rigth = 0; rigth < nums.length; rigth ++) { // 遍历数组
sum += nums[rigth]; // 与后指针元素进行相加
while (sum >= target) { // 判断满足 ≥ target
result = Math.min(result, rigth - letf + 1); // 取最短长度值 result 以往长度 rigth - letf + 1 当前长度
sum -= nums[letf]; // 准备移动前指针 将前指针元素减出 相加结果
letf++; // 移动前指针
}
}
return result == Integer.MAX_VALUE ? 0 : result; // 当 result 不等于初始长度则表明出现过 ≥ targe 取最短长度
}
}-
-
-
904.水果成篮
-
-
你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果 种类 。
你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：
你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。
给你一个整数数组 fruits ，返回你可以收集的水果的 最大 数目。
// 使用滑动窗口 两个指针 一前letf 一后rigth 一个记录最大数目ast 一个记录篮子中出现的果子种类的数量cont 一个新数组记录每种果子在篮子中存在的数量int[] f
// 示例：fruits = [1,2,1] 可以采摘全部 3 棵树。 fruits = [0,1,2,2] 可以采摘 [1,2,2] 这三棵树 如果从第一棵树开始采摘，则只能采摘 [0,1] 这两棵树。 fruits = [3,3,3,1,2,1,1,2,3,3,4] 可以采摘 [1,2,1,1,2] 这五棵树。
// 初始化int[] f 其下标为果树的序号 值为其果子存在于篮子中的数量 初始值为 0
// 移动后指针 开始摘果子 同时 f[fruits[rigth]] ++； 表示此种果树以摘一棵 当f[fruits[rigth]] == 1时表示第一次摘这种果树 则cont++ 表示以摘过的果树种类数量 记录最大数目
// 当 cont > 2 时 表示摘过的果树种类数量超过篮子数量2 应该从篮子里拿出果子 先把前指针的果树果子拿出来f[fruits[letf]] --； 移动前指针继续拿出果子 当 f[fruits[letf]] == 0 时表示此时前指针果树果子的以摘数量为0 即此种果子在篮子中不存在了cont==2 移动前指针； 记录最大数目；继续移动后指针往篮子里面添加果子 循环以往 直到遍历完全部果树 ast记录了最大数目
class Solution {
public int totalFruit(int[] fruits) {
if (fruits.length <= 2) { // 当果树小于等于2是 果树的数量就是可摘的最大数目
return fruits.length;
}
int cont = 0;
int letf = 0;
int ast = 2;
int[] f = new int[fruits.length]; // 记录每种果子在篮子中存在的数量
for (int rigth = 0; rigth < fruits.length ; rigth ++) { // 遍历全部果树
f[fruits[rigth]] ++; // 后指针果树往篮子里面添加果子 同时记录果子以摘数量++；
if (f[fruits[rigth]] == 1) { // 表示第一次摘这种果树
cont ++; // 摘过的果树种类数量++
}
while (cont > 2) { // 摘过的果树种类数量 > 2 需要从篮子里拿出果子
f[fruits[letf]] --; // 取出前指针果树的果子 同时记录果子以摘数量--；
if (f[fruits[letf]] == 0) cont --; // 当此前指针letf果树的果子以摘数量==0时 摘过的果树种类数量cont--
letf ++; // 移动前指针
}
ast = Math.max(ast, rigth - letf + 1); // 判断取最大数目 ast 以往数量 rigth - letf + 1 当前数量
}
return ast; // 返回最大数目
}
}-
-
-
76.最小覆盖子串
-
-
给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。
// 使用滑动窗口 两个指针 一前letf 一后rigth 一个记录子串长度size 一个记录还需覆盖的字符个数cont 一个记录子串的开始下标start（最后截取字符串用到） 一个记录每个字符还所需个数的数组int[] need
// 示例：s = "ADOBECODEBANC", t = "ABC" "BANC" s = "a", t = "aa" "" t 中两个字符 'a' 均应包含在 s 的子串中，因此没有符合条件的子字符串，返回空字符串。
// 初始化： cont 为 t字符串字符个数 size最小子串的字符个数 int[] need = new int[128];初始为包含每个字符所需个数为0 遍历t字符串 将t中每个字符的所需个数++
// 移动后指针读取每一个字符 首先判断在need中此字符所需个数是否大于0 大于则表示此字符是t中的字符 则还需覆盖的字符个数cont-- need中此字符所需个数-- 再次移动后指针追加遍历字符
// 直到还需覆盖的字符个数cont == 0 时 表示 letf - rigth的子串以包含字符串t 为找到最短包含子串 移动前指针letf 当 need[s.charAt(letf)] < 0 时表示letf指针处字符可以移除 多余的字符
// 使用while循环将左侧多余的字符移除后 判断其长度是否比size长度短 短则保存其值 并且记录子串的开始下标letf 继续寻找最短子串 移动前指针letf need[s.charAt(letf)]++;letf++;cont++; 会破坏当前子串包含t字符串的状态 继续从移动后指针开始执行，寻找新的满足条件的滑动窗口，如此反复，直到rigth超出了字符串S范围
class Solution {
public String minWindow(String s, String t) {
if (s == null || t == null || s.length() == 0 || t.length() == 0) { // 为空字符串时直接返回""
return "";
}
int[] need = new int[128]; // 定义包含所有字符的数组 记录每个字符还所需个数
for (int i = 0; i < t.length(); i++) { // 遍历t字符串
need[t.charAt(i)] ++; // 将t中每个字符的所需个数++
}
int letf = 0, rigth = 0, cont = t.length(), start = 0, size = Integer.MAX_VALUE; // 初始化
while (rigth < s.length()) { // 后指针rigth 遍历s字符串
char c = s.charAt(rigth); // 取出当前后指针指向的字符
if (need[c] > 0) { // 判断此字符是否为所需字符
cont --; // 是 则还需覆盖的字符个数cont--
}
need[c] --; // c字符以覆盖 所需个数--
if (cont == 0) { // t字符串以被全部覆盖 所需==0
while (letf < rigth && need[s.charAt(letf)] < 0) { // need[s.charAt(letf)] < 0 表示前指针letf指向字符为多余的字符 可以移除
need[s.charAt(letf)] ++; // 前指针letf指向字符 所需++ 移除此字符
letf ++; // 往后移动前指针
}
if (rigth - letf + 1 < size) { // 判断此时长度是否比记录最短 还短
start = letf; // 是 则 保存子串开始的下标
size = rigth - letf + 1; // 保存其子串长度
}
need[s.charAt(letf)] ++; // 保存完成 为继续寻找最短子串 破坏平衡
letf ++; // 往后移动前指针
cont ++; // 还需覆盖的字符个数cont++
}
rigth ++; // 移动后指针 包含下一个字符进来
}
return size == Integer.MAX_VALUE ? "" : s.substring(start, start+size); // 判断size是否为初始值 为 则未找到此子串返回"" 不为 则找到最短子串 根据start子串开始下标 至 start+size 结束下标 截取字符串
}
}-
-
螺旋矩阵
-
54.螺旋矩阵
-
-
给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。
// 顾名思义 先顺时针遍历最外层数组 再遍历第二层数组
// 首先设定上下左右边界 l = 0, r = matrix[0].length - 1, t = 0, b = matrix.length - 1
// 先遍历第一行从左至右 遍历完后将第一行移除数组 即上边界往下移 ++t 此时判断上下边界是否交错越界 是则表明螺旋矩阵遍历结束，跳出循环 否则表明还没有遍历完成 继续顺时针遍历
// 再遍历最右一列从上至下 遍历完后将最右一列移除数组 即右边界往左移 --r 此时判断左右边界是否交错越界 是则表明螺旋矩阵遍历结束，跳出循环 否则表明还没有遍历完成 继续顺时针遍历
// 再遍历最下一行从右至左 遍历完后将最下一行移除数组 即下边界往上移 --b 此时判断上下边界是否交错越界 是则表明螺旋矩阵遍历结束，跳出循环 否则表明还没有遍历完成 继续顺时针遍历
// 再遍历最左一列从下至上 遍历完后将最左一列移除数组 即左边界往右移 ++l 此时判断左右边界是否交错越界 是则表明螺旋矩阵遍历结束，跳出循环 否则表明还没有遍历完成 继续顺时针遍历
// 以此多次循环遍历 直至边界交错越界 表明螺旋矩阵遍历结束，跳出循环
class Solution {
public List<Integer> spiralOrder(int[][] matrix) {
List<Integer> res = new LinkedList<>(); // 定义新数组 存储顺时针遍历矩阵中的所有元素
if (matrix.length == 0) { // 数组长度==0 直接返回空新数组
return res;
}
int l = 0, r = matrix[0].length - 1, t = 0, b = matrix.length - 1, i; // 设定上下左右边界
while (true) { // 多次循环遍历 直至边界交错越界
for (i = l; i <= r; i++) { // 遍历第一行从左至右
res.add(matrix[t][i]);
}
if (++t > b) break; // 遍历完后将第一行移除数组 即上边界往下移 ++t 判断上下边界是否交错越界
for (i = t; i <= b; i++) { // 遍历最右一列从上至下
res.add(matrix[i][r]);
}
if (--r < l) break; // 遍历完后将最右一列移除数组 即右边界往左移 --r 判断左右边界是否交错越界
for (i = r; i >= l; i--) { // 遍历最下一行从右至左
res.add(matrix[b][i]);
}
if (--b < t) break; // 遍历完后将最下一行移除数组 即下边界往上移 --b 判断上下边界是否交错越界
for (i = b; i >= t; i--) { // 遍历最左一列从下至上
res.add(matrix[i][l]);
}
if (++l > r) break; // 遍历完后将最左一列移除数组 即左边界往右移 ++l 判断左右边界是否交错越界
}
return res; // 返回新数组 存储顺时针遍历矩阵中的所有元素
}
}-
-
-
59.螺旋矩阵2
-
-
给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。
// 定义当前左右上下边界 int l = 0, r = n - 1, t = 0, b = n - 1; 初始值 num = 1 为当前需要填入的值，迭代终止值 tar = n * n 即 sum > tar 时填充完成；生成需要填充的矩阵int[][] res = new int[n][n];
// 先从第一行从左至右填充元素 同时sum++ ，填充完后上边界往下移动 即 t++;
// 再从最右一列从上至下填充元素 同时sum++ ，填充完后右边界往左移动 即 r--;
// 再从最下一行从右至左填充元素 同时sum++ ，填充完后下边界往上移动 即 b--;
// 再从最左一列从下至上填充元素 同时sum++ ，填充完后左边界往右移动 即 l++;
// 以此循环填充 当 num <= tar 时，始终按照 从左到右 从上到下 从右到左 从下到上 填入顺序循环， 直至 sum > tar 时填充完成
class Solution {
public int[][] generateMatrix(int n) {
int l = 0, r = n - 1, t = 0, b = n - 1; // 定义当前左右上下边界
int[][] res = new int[n][n]; // 生成需要填充的矩阵
int sum = 1, tar = n * n, i; // num为当前需要填入的值 迭代终止值 tar = n * n
while (sum <= tar) { // 当 num <= tar 时，始终按照 从左到右 从上到下 从右到左 从下到上 填入顺序循环
for (i = l; i <= r; i++) res[t][i] = sum++; // 先从第一行从左至右填充元素 同时sum++
t++; // 填充完后上边界往下移动 即 t++
for (i = t; i <= b; i++) res[i][r] = sum++; // 再从最右一列从上至下填充元素 同时sum++
r--; // 填充完后右边界往左移动 即 r--
for (i = r; i >= l; i--) res[b][i] = sum++; // 再从最下一行从右至左填充元素 同时sum++
b--; // 填充完后下边界往上移动 即 b--
for (i = b; i >= t; i--) res[i][l] = sum++; // 再从最左一列从下至上填充元素 同时sum++
l++; // 填充完后左边界往右移动 即 l++
}
return res; // 返回填充好的矩阵
}
}
468
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
