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)