【数组基础】

最新推荐文章于 2024-06-18 16:27:13 发布

学海无涯le做舟

最新推荐文章于 2024-06-18 16:27:13 发布

阅读量118

点赞数

分类专栏：算法文章标签： leetcode 算法

本文链接：https://blog.csdn.net/qq_40043345/article/details/121791317

版权

算法专栏收录该内容

4 篇文章 0 订阅

订阅专栏

数组

数组理论基础

数组存储方式：在连续内存空间上的相同类型数据的集合。

数组元素获取：下标索引获取。

举例：

算法通关数组

注意点：

数组下标从0开始。
数组内存空间连续。

数组优缺点：查询快，增删慢；数组的元素是不能删除的，只能覆盖；

二分查找

力扣题目链接

二分查找是数组中运用较多的一类算法，使用二分法的前提是数组为有序数组。

二分法最主要的坑在于left 与 right该不该取等的问题；这就代表了我们的边界有不同的分法。

二分法第一种写法

第一种写法，我们定义 target 是在一个在左闭右闭的区间里，也就是[left, right] （这个很重要非常重要）。

定义target在[left, right]区间，所以有如下两点：

while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=
if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]不是target，那么接下来要查找的左区间结束下标位置就是 middle - 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);
            if (nums[mid] == target)
                return mid;
            else if (nums[mid] < target)
                left = mid + 1;
            else if (nums[mid] > target)
                right = mid - 1;
        }
        return -1;
    }
}

二分法第二种写法

如果说定义 target 是在一个在左闭右开的区间里，也就是[left, right) ，那么二分法的边界处理方式则截然不同。

有如下两点：

while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]

代码如下：

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;
    }
}

二分法主要就是对区间定义要清晰！循环中坚持根据查找区间的定义来做边界处理，就是循环不变量规则！

移除元素-快慢指针法

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。

示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

思路

第一种是暴力解法，也是很容易想到的方法，不做过多介绍。

代码如下：

// 时间复杂度：O(n^2)
// 空间复杂度：O(1)
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 + 1; j < size; j++) {
                    nums[j - 1] = nums[j];
                }
                i--; // 因为下表i以后的数值都向前移动了一位，所以i也向前移动一位
                size--; // 此时数组的大小-1
            }
        }
        return size;
    }
};

第二种我们用快慢指针法，也就是将目标元素不断往数组后面挪，慢指针指向的一定是数组中最靠前的目标元素，最后目标元素全部到数组的一端，我们只取前半部分非目标元素的长度就好。

代码如下：

class Solution {
    public int removeElement(int[] nums, int val) {

        // 快慢指针
        int fastIndex = 0;
        int slowIndex;
        for (slowIndex = 0; fastIndex < nums.length; fastIndex++) {
            if (nums[fastIndex] != val) {
                nums[slowIndex] = nums[fastIndex];
                slowIndex++;
            }
        }
        return slowIndex;
    }
}

有序数组的平方-双指针法

力扣题目链接

给你一个按非递减顺序排序的整数数组 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]

思路

暴力解法：

将所有数平方排序，时间复杂度为O(n + nlogn)

双指针法：

不难发现，平方之后所有元素是以0为分界限往左右进行递增的，因此我们可以利用双指针进行比较，将大的数逐一插入结果数组；

class Solution {
    public int[] sortedSquares(int[] nums) {
        int right = nums.length - 1;
        int left = 0;
        int[] result = new int[nums.length];
        int index = result.length - 1;
        while (left <= right) {
            if (nums[left] * nums[left] > nums[right] * nums[right]) {
                result[index--] = nums[left] * nums[left];
                ++left;
            } else {
                result[index--] = nums[right] * nums[right];
                --right;
            }
        }
        return result;
    }
}

长度最小的子数组-滑动窗口

力扣题目链接(opens new window)

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

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

思路

暴力解法

两个for循环，然后不断的寻找符合条件的子序列，时间复杂度很明显是O(n^2)

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int sublength = nums.length-1;
        int result = Integer.MAX_VALUE;;
        for(int i = 0;i<nums.length;i++){
            int sum = 0 ;
            for(int j = i;j<nums.length;j++){
                sum+=nums[j];
                if(sum>=target){
                    sublength = j-i+1;
                result = result<sublength?result:sublength;
                break;
                }
            }
        }
        return result == Integer.MAX_VALUE ? 0 :result;
    }
}

滑动窗口：

所谓滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。

在本题中实现滑动窗口，主要确定如下三点：

窗口内是什么？
如何移动窗口的起始位置？
如何移动窗口的结束位置？

窗口就是满足其和 ≥ s 的长度最小的连续子数组。

窗口的起始位置如何移动：如果当前窗口的值大于s了，窗口就要向前移动了（也就是该缩小了）。

窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，窗口的起始位置设置为数组的起始位置就可以了。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
       int l = 0 ;
       int result = Integer.MAX_VALUE;
        int sum = 0;
       for(int r = 0 ; r<nums.length;r++){
           sum+=nums[r];
           while(sum>=target){
               result = Math.min(result,r-l+1);
               sum -=nums[l++]; //这一步就是不断移动窗口的精髓
           }
       }
       return result == Integer.MAX_VALUE? 0 : result;
    }
}

螺旋矩阵II

力扣题目链接(opens new window)

给定一个正整数 n，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。

示例:

输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]

思路

按照左闭右开的原则，来画一圈:

螺旋矩阵

代码如下：

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] res = new int[n][n];

        // 循环次数
        int loop = n / 2;

        // 定义每次循环起始位置
        int startX = 0;
        int startY = 0;

        // 定义偏移量 
        int offset = 1;

        // 定义填充数字
        int count = 1;

        // 定义中间位置 
        int mid = n / 2;
        
        while (loop > 0) {
            int i = startX;
            int j = startY;

            // 模拟上侧从左到右 n-offset就表示了每次循环的步长
            for (; j<startY + n -offset; ++j) {
                res[startX][j] = count++;
            }

            // 模拟右侧从上到下
            for (; i<startX + n -offset; ++i) {
                res[i][j] = count++;
            }

            // 模拟下侧从右到左
            for (; j > startY; j--) {
                res[i][j] = count++;
            }

            // 模拟左侧从下到上
            for (; i > startX; i--) {
                res[i][j] = count++;
            }

            loop--;

            startX += 1;
            startY += 1;

            offset += 2;
        }
		
        //奇数需要特殊处理
        if (n % 2 == 1) {
            res[mid][mid] = count;
        }

        return res;
    }
}

总结

数组的重点，一个是存储的连续性，正是**因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。**二维数据在内存中不是的连续地址空间，而是N条连续的地址空间组成！另一个则是元素的不可删除，只能覆盖。

学海无涯le做舟

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【数组基础】

数组目录数组数组理论基础二分查找二分法第一种写法二分法第二种写法移除元素-快慢指针法思路有序数组的平方-双指针法思路长度最小的子数组-滑动窗口思路螺旋矩阵II思路总结数组理论基础数组存储方式：在连续内存空间上的相同类型数据的集合。数组元素获取：下标索引获取。举例：注意点：数组下标从0开始。数组内存空间连续。数组优缺点：查询快，增删慢；数组的元素是不能删除的，只能覆盖；二分查找力扣题目链接二分查找是数组中运用较多的一类算法，使用二分法的前提是数组为有序数组。二分法最主要的坑在于
复制链接

扫一扫