LeetCode数组——代码随想录

最新推荐文章于 2024-06-27 21:47:06 发布

洋间

最新推荐文章于 2024-06-27 21:47:06 发布

阅读量117

点赞数

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

本文链接：https://blog.csdn.net/qq_45568467/article/details/130547295

版权

LeetCode 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

复杂度介绍

算法导论给出的解释：大O用来表示上界的，当用它作为算法的最坏情况运行时间的上界，就是对任意数据输入的运行时间的上界。

递归算法的时间复杂度本质上是要看: 递归的次数 * 每次递归中的操作次数。

递归算法的空间复杂度 = 每次递归的空间复杂度 * 递归深度

**那么思考一下什么时候空间复杂度是 O(logn)呢？递归 **

// 版本二
int fibonacci(int first, int second, int n) {
    if (n <= 0) {
        return 0;
    }
    if (n < 3) {
        return 1;
    }
    else if (n == 3) {
        return first + second;
    }
    else {
        return fibonacci(second, first + second, n - 1);
    }
}

相当于从头加，用first和second来记录当前的两个数值，而不是重复计算同样的值。

时间复杂度：O(n)
空间复杂度：O(n)

int fibonacci(int i) {
       if(i <= 0) return 0;
       if(i == 1) return 1;
       return fibonacci(i-1) + fibonacci(i-2);
}

时间复杂度为O(2^n)，大量重复计算。空间复杂度就是O(n)。（递归深度为O(n)）

数组

704. 二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1

初步

class Solution {
    public int search(int[] nums, int target) {
        int low = 0;
        int high = nums.length-1;
        int mid = (high+low)/2;
        while(low <= high){
            if (target == nums[mid]) {
                return mid;
            }else if(target < nums[mid]) {
               	high = mid-1;
            }else {
                low = mid+1;
            }
            mid = (high+low)/2;
        }
        return -1;
    }
}

Q1: 最开始的想法是

           high = mid;
        }else {
            low = mid;
        }
        mid = (high+low)/2;

当low/high相邻时，此时因为 low/high 会陷入等于mid不变的bug，不能正确对比和变化。

27. 移除元素

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

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

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

暴力解法

最开始只想到了暴力解法，还有很多问题比如数组越界访问和覆盖后原位置不再次检测的bug。

class Solution {
    public int removeElement(int[] nums, int val) {
        int length = nums.length;
        for(int i = 0; i <= length-1; i++){
            if(nums[i] == val){
                for (int j= i; j <= length-2; j++){
                    nums[j] = nums[j+1];
                }
                length--;//新长度防止越界
                i--;//回到覆盖移动后的本位置继续检测
            }
        }
        return length;
    }
}

Q：第一层循环遇到目标值，每次都依次覆盖后面的值而且不管值是什么，双层循环时间复杂度过高O(n^2)，有没有一种办法让一次循环解决问题？可采用扫描并填充的方式，即快慢指针。

时间复杂度：O(n^2)
空间复杂度：O(1)

双指针法 (20:30)

class Solution {
    public int removeElement(int[] nums, int val) {
        int slow = 0;
        for(int fast = 0; fast<= nums.length-1; fast++) {
            if (nums[fast] != val) {
                nums[slow++] = nums[fast];
            }
        }
        return slow;
    }
}

时间复杂度：O(n)
空间复杂度：O(1)

虽然双指针法解决了两次循环，并避免了移动不需要的值。但是他仍然移动了需要保留的值，还有一种方法可以在最小程度移动值。
在这里插入图片描述

双指针优化（20：52）

第一版：

class Solution {
    public int removeElement(int[] nums, int val) {
        int left = 0;
        int right = nums.length - 1;
        while(left <= right) {
            while(left <= right && nums[left] != val ) {
                ++left;//找到左侧需要被替换的值
            }
            while(left <= right && nums[right] == val  ) {
                --right;//找到右侧替换的候选值
            }
            if(left <= right){
                nums[left++] = nums[right--];
            }
        }
        return left;
    }
}

在这里插入图片描述

bug:

nums[right] == val && left <= right

right存在负值情况，如果先判断前面则出现越界！！！

官方：

class Solution {
    public int removeElement(int[] nums, int val) {
        int left = 0;
        int right = nums.length-1;
        while (left <= right) {
            if (nums[left] == val) {
                nums[left] = nums[right];
                right--;
            } else {
                left++;//所有的都更换，不管右侧是否为需要被替换的,一个位置多次替换
            }
        }
        return left;
    }
}

977. 有序数组的平方

给你一个按非递减顺序排序的整数数组 nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。

1.无脑暴力法

采用了最简单暴力的解法，先平方，再排序，排序采用最垃圾的算法。

class Solution {
    public int[] sortedSquares(int[] nums) {
        for (int i = 0; i<=nums.length-1 ; i++){
            nums[i] = nums[i]*nums[i];
        }
         for (int i = 0; i<=nums.length-1; i++){
           for(int j = i; j<= nums.length-1; j++){
               if(nums[i]>nums[j]){
                   int t = nums[i];
                   nums[i] = nums[j];
                   nums[j] = t;
               }
           }//或者快速排序，O(nlogn)的时间复杂度。
        }
        return nums;
    }
}

时间复杂度为耗时的垃圾排序O(n^2+n)，空间复杂度为O(1)。

此时，没有利用到题中已经进行过非递减排序的条件，因为最大的值一定在两端且按照大小分别进行正反向排序，所以可以利用双指针法。

2.双指针法

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

时间复杂度为O(n)，空间复杂度O(n)。

代码随想录版本（使用while循环）：

class Solution {
    public int[] sortedSquares(int[] nums) {
        int left = 0;
       	int right = nums.length - 1;
        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;
    }
}

在这里插入图片描述

209. 长度最小的子数组

暴力解法：简简单单超个时

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int min = 0;
        int length = 0;
        for(int i = 0; i<= nums.length-1; i++) {
			int sum = 0;
            for(int j= i;j<= nums.length-1;j++) {
                sum = sum + nums[j];
                length = j - i + 1;
                if(sum >= target && (length<=min || min==0)) {
                    min = length;
                    break;
                }
            }
        }
        return min;
    }
}

时间复杂度O(n^2)，且是所有情况都双层遍历相加，有大量的重复加法，当数据量较大时，时间过长。

双指针法：滑动窗口

可以利用连续子数组这个特征，通过两个指针，操作头尾数，来减少重复计算。

第一版：

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int min = 0;
        int fast = 0;
        int slow = 0;
        int sum =  0;
        while(fast <= nums.length-1) {
            sum = sum + nums[fast];
            if(sum >= target){
                while(sum - nums[slow] >= target) {
                     sum = sum - nums[slow];
                     slow++;         
                }
                if(min == 0 || fast - slow + 1 < min) {
                    min = fast - slow + 1;   
                }                                                           
            }
            fast++;
        }
        return min;
    }
}

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1yGM0hXJ-1683462175199)(D:\notebook\Working\algorithm\代码随想录.assets\image-20230424220627055.png)]$

优化版本：

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int min = 0, fast = 0, slow = 0, sum = 0;
        while(fast<=nums.length-1) {
            sum = sum +nums[fast];
            while(sum>=target) {
                if(min == 0 ||fast - slow + 1 < min){
                    min = fast - slow + 1;   
                }
                sum = sum - nums[slow++];
            }
            fast++;
        }
        return min;
    }
}

时间复杂度是O(n)，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n 也就是O(n)。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qGwN7Xxu-1683462175200)(D:\notebook\Working\algorithm\代码随想录.assets\image-20230424222319515.png)]$

长度最小的子数组.html#相关题目推荐相关题目推荐通过滑动的窗口，只进行左右两个值的计算，避免了大量重复运算。

59. 螺旋矩阵 II

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

最直观的方法：绕圈

class Solution {
    public int[][] generateMatrix(int n) {
        int [][] result = new int[n][n];
        int index =2 ;
        int num = n*n;
        int row = 0;
        int column =0;
        result[0][0]=1;
        while(index <= num){
            while(column< n-1 && result[row][column+1] == 0){
                result[row][++column] = index++;//看下一个需要填充的位置，如果判断本位置当在拐角时已经被填充，无法进入循环。
            }
            while(row< n-1 && result[row+1][column] == 0){
                result[++row][column] = index++;
            }
            while(column >0 && result[row][column-1] == 0){
                result[row][--column] = index++;

            }while(row>0  && result[row-1][column] == 0){
                result[--row][column] = index++;
            }
        }
        return result;
    }
}

时间复杂度：O(n^2），空间复杂度：O(1)

按层次填充

class Solution {
    public int[][] generateMatrix(int n) {
        int num = 1;
        int[][] matrix = new int[n][n];
        int left = 0, right = n - 1, top = 0, bottom = n - 1;
        while (left <= right && top <= bottom) {
            for (int column = left; column <= right; column++) {//小细节，column<=right
                matrix[top][column] = num;
                num++;
            }
            for (int row = top+1; row <= bottom-1; row++) {
                matrix[row][right] = num;
                num++;
            }
            for (int column = right; column >= left+1; column--) {
                matrix[bottom][column] = num;
                num++;
             }
            for (int row = bottom; row >= top+1; row--) {
                matrix[row][left] = num;
                num++;
            }
            left++;
            right--;
            top++;
            bottom--;
        }
        return matrix;
    }
}

Bug: column <= right 这种相似条件必须在四个for中至少出现一个，因为当n为奇数时，最后左右上下相等，必须存在一个合理的条件来赋值。

时间复杂度：O(n^2），空间复杂度：O(1)

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ravksBF8-1683462175200)(D:\notebook\Working\algorithm\代码随想录.assets\image-20230426221640315.png)]$

洋间

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
LeetCode数组——代码随想录

当用它作为算法的最坏情况运行时间的上界，就是对任意数据输入的运行时间的上界。递归算法的时间复杂度本质上是要看:。**那么思考一下什么时候空间复杂度是 O(logn)呢？递归 **相当于从头加，用first和second来记录当前的两个数值，而不是重复计算同样的值。时间复杂度为O(2^n)，大量重复计算。空间复杂度就是O(n)。（递归深度为O(n)）
复制链接

扫一扫

专栏目录