01 数组-常见题型及思路总结
【Day1 ~ 2】-【代码随想录训练营20期】打卡
数组总结
一、数组理论基础
1. 数组的定义： 数组是存放在连续内存空间上的相同类型数据的集合。
在Java中，数组是一个引用类型，意味着数组本身是一个对象，而数组元素可以是基本数据类型或其他对象。因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。
2. 创建数组： 在Java中，可以通过以下方式来创建数组：
// 声明并创建一个整数数组，长度为5
int[] intArray = new int[5];
// 声明并创建一个字符串数组，长度为3
String[] stringArray = new String[3];
3. 访问数组元素： 数组元素可以通过索引访问，索引从0开始，依次递增。例如：
intArray[0] = 10; // 设置第一个元素为10
int firstElement = intArray[0]; // 获取第一个元素的值
4. 数组长度： 可以使用length属性来获取数组的长度，即数组中元素的个数。例如：
int length = intArray.length; // 获取intArray数组的长度
5. 数组初始化： 数组可以在创建时进行初始化，可以使用以下方式：
int[] initializedArray = {1, 2, 3, 4, 5}; // 初始化整数数组
String[] words = {"hello", "world"}; // 初始化字符串数组
6. 多维数组： Java也支持多维数组，如二维数组、三维数组等。多维数组可以看作是数组的数组。例如：
int[][] twoDimensionalArray = new int[3][3]; // 声明一个3x3的二维数组
int value = twoDimensionalArray[1][2]; // 访问二维数组中的元素7. 数组操作： Java提供了一些方法和技巧来操作数组，例如：
- 循环遍历数组：使用
for循环或者增强型for-each循环来遍历数组元素。 - 数组排序：可以使用
Arrays类的sort方法对数组元素进行排序。 - 数组复制：使用
Arrays类的copyOf方法来复制数组。
8. 异常处理： 在访问数组元素时，如果使用了超出数组范围的索引，将会抛出ArrayIndexOutOfBoundsException异常。
9. 动态数组： 虽然传统的数组长度是固定的，但是Java中也有类似动态数组的数据结构，例如ArrayList，它可以根据需要自动调整大小。
10. 数组的局限性：
- 数组长度固定：一旦数组被创建，其长度无法改变。
- 数组只能存储相同数据类型的元素。
二、二分查找
704.二分查找
给定一个
n个元素有序的（升序）整型数组nums和一个目标值target，写一个函数搜索nums中的target，如果目标值存在返回下标，否则返回-1。
思路：
二分法：数组为有序数组，同时无重复元素。
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;
while (left <= right) {
int mid = left + ((right - left) >> 1);
// >>是位运算符，将结果右移一位，相当于除以2
if (nums[mid] == target)
return mid;
else if (nums[mid] < target)
//target在中线右边，更新左边界
left = mid + 1;
else if (nums[mid] > target)
//target在中线左边，更新右边界
right = mid - 1;
}
return -1;
}
}2. 左闭右开区间：左边闭合右边开，不能取到右边界，代码就需要做出一些改变
class Solution {
public int search(int[] nums, int target) {
int left = 0, right = nums.length;
while (left < right) {
//左右边界不能相等，因为右边界开区间
int mid = left + ((right - left) >> 1);
if (nums[mid] == target)
return mid;
else if (nums[mid] < target)
left = mid + 1;
else if (nums[mid] > target)
//右边界开区间的，所以不能等
right = mid;
}
return -1;
}
}三、移除元素
27.移除元素
给你一个数组
nums和一个值val，你需要 原地 移除所有数值等于val的元素，并返回移除后数组的新长度。不要使用额外的数组空间，你必须仅使用
O(1)额外空间并 原地 修改输入数组。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
思路
限制O(1)空间，也就是不能新创建数组进行拷贝
1. 暴力解法：用两个for循环遍历，第一个是找到数值等于val的元素，第二个是用后一个元素覆盖前一个元素。
2. 双指针-单向快慢指针：一个快指针右移找到数值等于val的元素，一个慢指针右移并复制快指针的元素，并且在快指针遇到val的时候停下并休克。
3. 双指针-双向指针：因为该题目不要求元素的顺序，所以可以用。首先右指针移动到右数第一个不为val的数值，然后左指针右移找到数值等于val的元素，右指针赋值给左指针。其中左指针的移动条件：数值不为val，右指针的移动条件：赋值给左指针或数值为val。
暴力解法
class Solution {
public int removeElement(int[] nums, int val) {
int size = nums.length;
for(int i = 0; i < size; i++){
if(nums[i] == val){
for(int j = i; j < size - 1; j++){
nums[j] = nums[j+1];
}
--i;
--size;
}
}
return size;
}
}- 时间复杂度：O(n^2)
- 空间复杂度：O(1)
双指针-单向快慢指针
class Solution {
public int removeElement(int[] nums, int val) {
// 快慢指针
int slowIndex = 0;
for (int fastIndex = 0; fastIndex < nums.length; fastIndex++) {
if (nums[fastIndex] != val) {
nums[slowIndex] = nums[fastIndex];
slowIndex++;
}
}
return slowIndex;
}
}- 时间复杂度：O(n)
- 空间复杂度：O(1)
双指针-双向指针
//相向双指针法
class Solution {
public int removeElement(int[] nums, int val) {
int left = 0;
int right = nums.length - 1;
while(right >= 0 && nums[right] == val) right--; //将right移到从右数第一个值不为val的位置
while(left <= right) {
if(nums[left] == val) { //left位置的元素需要移除
//将right位置的元素移到left（覆盖），right位置移除
nums[left] = nums[right];
right--;
}
left++;
while(right >= 0 && nums[right] == val) right--;
}
return left;
}
}- 时间复杂度：O(n)
- 空间复杂度：O(1)
三、有序数组的平方
977.有序数组的平方
给你一个按 非递减顺序 排序的整数数组
nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
思路：
0. 是否可以暴力解？可以，直接创建新数组并排序即可。
1. 该数组实际上是排序的，从小到大，从负数到零到正数。
2. 新数组的排序实际上是按照其平方大小排序，那么对于一个有负数的数组，两端大于中间，自然想到了双指针-双向指针。
3. 没有提及空间复杂度，可以创建新数组进行拷贝。
4. 具体思路：若有负数，则设左右指针，每次比较左右指针的平方大小，大者从右往左赋值给新数组并往中间移动一次。
双指针-双向指针
class Solution {
public int[] sortedSquares(int[] nums) {
int leftIndex = 0;
int rightIndex = nums.length - 1;
int newNums[] = new int [nums.length];
int resultIndex = nums.length - 1;
while(leftIndex <= rightIndex){
if(nums[leftIndex]*nums[leftIndex] > nums[rightIndex]*nums[rightIndex]){
newNums[resultIndex] = nums[leftIndex]*nums[leftIndex];
++leftIndex;
--resultIndex;
}else{
newNums[resultIndex] = nums[rightIndex]*nums[rightIndex];
--rightIndex;
--resultIndex;
}
}
return newNums;
}
}时间复杂度为O(n)
空间复杂度为O(n)
四、长度最小的子数组
209. 长度最小的子数组
给定一个含有
n个正整数的数组和一个正整数target。找出该数组中满足其和
≥ target的长度最小的 连续子数组[numsl, numsl+1, ..., numsr-1, numsr]，并返回其长度。如果不存在符合条件的子数组，返回0。
思路：
0. 该题可以暴力破解，用两个for循环，把每种可能性遍历一次。
1. 连续数组，首先考虑到双指针，由于是连续子数组，可以考虑双指针-快慢指针。
2. 快指针的移动条件：快慢指针区间和小于target。慢指针移动条件：快慢指针区间和大于target。
ps：这种快慢指针区间和的变种，也被形象地称为滑动窗口。注意指针移动方向一致时，最好采用for循环（循环条件为数组长度），当相向指针时才采用while循环（循环条件为左右指针相交）。
class Solution {
// 滑动窗口
public int minSubArrayLen(int s, int[] nums) {
int left = 0; // 滑动窗口的左边界
int sum = 0; // 当前窗口内元素的和
int result = Integer.MAX_VALUE; // 存储最小子数组长度的结果，初始化为最大值
for (int right = 0; right < nums.length; right++) {
// 将当前右边界的元素添加到窗口内
sum += nums[right];
// 当窗口内元素和大于等于目标值s时，进入循环
while (sum >= s) {
// 更新结果为窗口长度和当前结果中的较小值
result = Math.min(result, right - left + 1);
// 缩小窗口，从左边界移除一个元素，更新窗口内元素和
sum -= nums[left++];
}
}
// 如果结果仍然是初始值，说明没有找到满足条件的子数组，返回0；否则返回最小子数组长度
return result == Integer.MAX_VALUE ? 0 : result;
}
}
五、螺旋矩阵
59. 螺旋矩阵 II
给你一个正整数
n，生成一个包含1到n2所有元素，且元素按顺时针顺序螺旋排列的n x n正方形矩阵matrix。
思路：
1. 该题目主要就是边界问题，有两个常见思路，一个是归纳，二是模拟，用模拟做的题目范围会更大。
2. 注意将边界统一，即每一层螺旋四个边的长度是一致的。
3. 将边界条件用代码表示出来，由于每一层都有四个边，可以用while循环包起来。
4. 注意特殊情况，当n=1时，当n为奇数或偶数时。
思路1：归纳
class Solution {
public int[][] generateMatrix(int n) {
int layerNumber = 0;//螺旋层数
int[][] matrix = new int[n][n];//矩阵
int temp = 0;//储存每块最后输出的数字
boolean loop = true;//是否还有层数的条件
int x1,y1,x2,y2,x3,y3,x4,y4,number;
if(n == 1){
matrix[0][0] = 1;
return matrix;
}
while(loop){
x1 = layerNumber;
y1 = layerNumber;
x2 = layerNumber;
y2 = n - 1 - layerNumber;
x3 = n - 1 - layerNumber;
y3 = n - 1 - layerNumber;
x4 = n - 1 - layerNumber;
y4 = layerNumber;
number = n - (2 * layerNumber) - 1;//每层每块数字数量
for(int i = 0; i < number; i++){
matrix[x1][y1] = temp + i + 1;
matrix[x2][y2] = matrix[x1][y1] + number;
matrix[x3][y3] = matrix[x2][y2] + number;
matrix[x4][y4] = matrix[x3][y3] + number;
++y1;
++x2;
--y3;
--x4;
}
temp = matrix[x4+1][y4];
++layerNumber;
if(layerNumber > n/2 - 1){
if(n%2 == 1){
matrix[n/2][n/2] = n*n;
}
loop = false;
}
}
return matrix;
}
}时间复杂度：O(n*n)
空间复杂度：O(n*n)
思路2：模拟
class Solution {
public int[][] generateMatrix(int n) {
int loop = 0; // 控制循环次数
int[][] res = new int[n][n];
int start = 0; // 每次循环的开始点(start, start)
int count = 1; // 定义填充数字
int i, j;
while (loop++ < n / 2) { // 判断边界后，loop从1开始
// 模拟上侧从左到右
for (j = start; j < n - loop; j++) {
res[start][j] = count++;
}
// 模拟右侧从上到下
for (i = start; i < n - loop; i++) {
res[i][j] = count++;
}
// 模拟下侧从右到左
for (; j >= loop; j--) {
res[i][j] = count++;
}
// 模拟左侧从下到上
for (; i >= loop; i--) {
res[i][j] = count++;
}
start++;
}
if (n % 2 == 1) {
res[start][start] = count;
}
return res;
}
}时间复杂度：O(n*n)
空间复杂度：O(n*n)