个人做 下载类网站友情链接检索数据分析

5.13 数组总结

数组是存放在连续内存空间上的相同类型数据的集合。

数组可以方便的通过下标索引的方式获取到下标对应的数据。

正是因为数组在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。

数组的元素是不能删的，只能覆盖。

• 二分法：循环不变量原则，只有在循环中坚持对区间的定义，才能清楚的把握循环中的各种细节。

  二分法是算法面试中的常考题，建议通过这道题目，锻炼自己手撕二分的能力。

• 双指针法：移除一个数字

  双指针法（快慢指针法）：通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

• class Solution {
  public:int removeElement(vector<int>& nums, int val) {int slowIndex = 0;for (int fastIndex = 0; fastIndex < nums.size(); fastIndex++) {if (val != nums[fastIndex]) {nums[slowIndex++] = nums[fastIndex];}}return slowIndex;}
  };
  

• 滑动窗口：

  滑动窗口如何移动 窗口起始位置，达到动态更新窗口大小的，从而得出长度最小的符合条件的长度。

  滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)的暴力解法降为O(n)。

= g.length - 1 ; i >= 0 ; i–){
if(sIndex >= 0 && s[sIndex] >= g[i]){
res++;
sIndex–;
}
}
return res;
};

总结：这一道题就是典型的贪心算法问题，大饼干肯定满足大胃口和小胃口，所以从最大的饼干开始遍历，依次遍历大胃口到小胃口。注意判断条件，因为sIndex是饼干，它要大于0才能进行比较和移动指针。# 4.30 数组合集---二分查找\704. 二分查找已解答简单相关企业给定一个 `n` 个元素有序的（升序）整型数组 `nums` 和一个目标值 `target`  ，写一个函数搜索 `nums` 中的 `target`，如果目标值存在返回下标，否则返回 `-1`。**示例 1:**

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

**示例 2:**

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

**提示：**1. 你可以假设 `nums` 中的所有元素是不重复的。
2. `n` 将在 `[1, 10000]`之间。
3. `nums` 的每个元素都将在 `[-9999, 9999]`之间。因为学校有算法课，但是用的c++，我就一直没有听，在写这个题目之前我真的觉得这个很简单，因为我已经写过很多次了，但是真正写了才发现什么是一写就废。首先ts里面的除法是会有小数点的，应该使用math里面的四舍五入

mid = Math.floor((low + up) / 2 );

没有正确理解区间：它可以是左闭右闭区间：while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1也可以是左闭右开区间：while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]最终代码：

function search(nums: number[], target: number): number {
let low : number = 0 ;
let up : number = nums.length;
let mid : number;
while(low < up){
mid = Math.floor((low + up) / 2 );
if(nums[mid] === target) return mid;
else if (nums[mid] > target) up = mid ;
else low = mid + 1;
}
return -1;

};

# 5.8 数组合集---有序数组的平方给你一个按 **非递减顺序** 排序的整数数组 `nums`，返回 **每个数字的平方** 组成的新数组，要求也按 **非递减顺序** 排序。**示例 1：**

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

**示例 2：**

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

**提示：**- `1 <= nums.length <= 104`
- `-104 <= nums[i] <= 104`
- `nums` 已按 **非递减顺序** 排序我的思路：暴力解法每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。我的思路：遍历平方之后使用sort代码：

function sortedSquares(nums: number[]): number[] {

for(let i = 0 ; i < nums.length ; i++){nums[i] = nums[i] * nums[i];}nums.sort((a , b) => {return a - b});return nums;

};

双指针思路：因为要求是递增嘛，我们设两个指针指向原数组的首尾端，设置一个新的数组，从最后开始插入数字我的代码：

let i = 0 , j = nums.length - 1;
let k = nums.length - 1; ;
let res = [];
while( i <= j){
let ans1 = nums[i] * nums[i];
let ans2 = nums[j] * nums[j];
if(ans1 > ans2){
res[k] = ans1;
k–;
i++;
}else {
res[k] = ans2;
k–;
j–;
}
}
return res;

总结：在数组中，双指针是一个很好的方法# 5.9 数组合集---长度最小的子数组给定一个含有 `n` 个正整数的数组和一个正整数 `target` **。**找出该数组中满足其总和大于等于 `target` 的长度最小的 **子数组** `[numsl, numsl+1, ..., numsr-1, numsr]` ，并返回其长度**。**如果不存在符合条件的子数组，返回 `0` 。**示例 1：**

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

**示例 2：**

输入：target = 4, nums = [1,4,4]
输出：1

**示例 3：**

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

**提示：**- `1 <= target <= 109`
- `1 <= nums.length <= 105`
- `1 <= nums[i] <= 104`**进阶：**- 如果你已经实现 `O(n)` 时间复杂度的解法, 请尝试设计一个 `O(n log(n))` 时间复杂度的解法。我的思路：双指针，滑窗思想[2,3,1,2,4,3]​         *​           *2<7 res++ j++2 + 3 < 7  res++ j++5 + 1 < 7  res++ j++6 + 2 > 7 res-- i++ 8-2 = 66 < 7 j++  6 + 4 > 7 res-- i++  10-3 = 7 = 7 res-- i++7 - 2 = 5 5 + 3 = 8 res-- i++   8-2 = 6当sum<target => res++ , j++ sum+=当sum >= tartget => res-- , i++ sum-=  缩小窗口总的来说sum>=target的时候进行缩小窗口操作，其他的进行扩大窗口的操作我的代码：

function minSubArrayLen(target: number, nums: number[]): number {
let i = 0 ;
let j = 0;
let min = Infinity;
// [1,4,4]
let sum = 0 ;
while(j < nums.length ){
sum += nums[j];
while(sum >= target){
min = Math.min(min , j - i + 1);
sum -= nums[i];
i++;
}
j++;
}
return min === Infinity ? 0 : min;
};

# 5.12 数组合集---59.螺旋矩阵给你一个正整数 `n` ，生成一个包含 `1` 到 `n2` 所有元素，且元素按顺时针顺序螺旋排列的 `n x n` 正方形矩阵 `matrix` 。**示例 1：**

输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]

**示例 2：**

输入：n = 1
输出：[[1]]

**提示：**- `1 <= n <= 20`这道题目可以说在面试中出现频率较高的题目，**本题并不涉及到什么算法，就是模拟过程，但却十分考察对代码的掌控能力。**我的思路：其实我最开始是没有思路的，除了一昧的循环，我没有任何思路，看到题解使用的边界方法，我突然领悟了

生成一个包含 1 到 n2 所有元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix
生成一个正方形的矩阵，它的值是元素按顺时针螺旋排列得到的
i j
00 01 02
10 11 12
20 21 22
定义边界
r=2 l=0 t=0 b=2
for(int i = 0 ; i < r ; i++){
[top][i]
top++
}
for(let j = top ; j < b ; j++){
[j][r]
r–;
}
for(let k = r ; k > l ; k-- ){
[b][k]
b–;
}
for(let m = b ; m > t ; m==){
[m][l];
l++
}

但是实现起来却没有这么简单：- 矩阵声明问题：我最开始是用的- ```let res : number[][] = [];

但是这样的声明不会创建一个n x n的二维数组，而是创建了一个空数组

• let res = new Array(n).fill(0).map(() => new Array(n).fill(0));
  

最终代码：

function generateMatrix(n: number): number[][] {// 定义边界let r = n - 1 , l = 0 , t = 0 , b = n - 1;const total = n * n ; let num = 1 ; // 这样的声明不会创建一个n x n的二维数组，而是创建了一个空数组。let res = new Array(n).fill(0).map(() => new Array(n).fill(0));while(num <= total){for(let i = l ; i <= r ; i++){res[t][i] = num;num++;}t++;for(let j = t ; j <= b ; j++){res[j][r] = num;num++;}r--;for(let k = r ; k >= l ; k--){res[b][k] = num;num++;}b--;for(let m = b ; m >= t ; m--){res[m][l] = num;num++;}l++;}return res;};

总结：这样的螺旋问题可以使用边界法，边界是动态的，我们循环的时候注意一下边界就好啦

5.13 数组总结

数组是存放在连续内存空间上的相同类型数据的集合。

数组可以方便的通过下标索引的方式获取到下标对应的数据。

正是因为数组在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。

数组的元素是不能删的，只能覆盖。

• 二分法：循环不变量原则，只有在循环中坚持对区间的定义，才能清楚的把握循环中的各种细节。

  二分法是算法面试中的常考题，建议通过这道题目，锻炼自己手撕二分的能力。

• 双指针法：移除一个数字

  双指针法（快慢指针法）：通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

• class Solution {
  public:int removeElement(vector<int>& nums, int val) {int slowIndex = 0;for (int fastIndex = 0; fastIndex < nums.size(); fastIndex++) {if (val != nums[fastIndex]) {nums[slowIndex++] = nums[fastIndex];}}return slowIndex;}
  };
  

• 滑动窗口：

  滑动窗口如何移动 窗口起始位置，达到动态更新窗口大小的，从而得出长度最小的符合条件的长度。

  滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)的暴力解法降为O(n)。