算法随笔—数组(持续更新...)

最新推荐文章于 2024-09-15 09:47:04 发布

rarison代码随录

最新推荐文章于 2024-09-15 09:47:04 发布

阅读量77

点赞数

文章标签： java 算法 leetcode Powered by 金山文档

本文链接：https://blog.csdn.net/rarison/article/details/129740918

版权

寻找数组的中心索引

LeetCode 1991题：https://leetcode-cn.com/problems/find-the-middle-index-in-array/

思路分析：

中心下标的左右两侧的元素相加的和相等，因此可以先通过遍历数组，求得数组元素的总和。然后再次遍历数组

初始 Left = 0；Right = Sum

此时每遍历一个元素，Right = Sum -arr [i] , 判断 Left == Right

true 则返回该元素下标 i，false 则 Left = Left - arr[i] 继续遍历

没有找到则返回 -1；

class Solution {
    public int pivotIndex(int[] nums) {
        int sum = 0;
        for(int i = 0;i < nums.length;i++){
            sum += nums[i];
        }
        int left = 0;
        int right = sum;
        for(int i = 0;i < nums.length;i++){
            right = right - nums[i];
            if(left == right){
                return i;
            }
            left += nums[i];
        }
        return -1;
    }
}

二分法查找

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

关键词：有序数组数组中无重复元素

二分法中一般有两种写法，主要是针对于左右区间闭合的问题，即 [left, right] [left, right）

此时就涉及到两种版本的代码写法，先看代码

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

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

差别最先在于取值区间的问题，当 [left, right] 时，right = right -1；因此 left <= right 有意义，所以while 循环中有等号。当 [left, right）时，由于取不到区间 rigth，并且在后面的赋值中， right = mid，因此等号此时没有意义。

题目：【搜索插入位置】给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。请必须使用时间复杂度为 O(log n) 的算法。

链接：https://leetcode.cn/leetbook/read/array-and-string/cxqdh/

思路：仍然可以使用二分法查，如果目标不在数组中，此时退出后 left 值最接近 target 并且大于 target，因此 return left.

class Solution {
    public int searchInsert(int[] nums, int target) {
        int left = 0;
        int right = nums.length-1;
        if(target < nums[left]){
            return 0;
        }else if(target > nums[right]){
            return nums.length;
        }
    
        while(left <= right){
            int mid = left + ((right - left)>>1);
            if(nums[mid] == target){
                return mid;
            }else if(nums[mid]>target){
                right = mid-1;
            }else{
                left = mid +1;
            }
        }
        return left;
    }
}

移除数组元素

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。链接：https://leetcode.cn/problems/remove-element

思路分析

首先要求是返回元素的个数，其次，只能在原数组上进行更改，不考虑超出新长度后面的元素【因为数组的长度是固定的，当移除目标元素后，后面的元素向前补位，后面的元素不需要考虑】

1.暴力解法：两层for循环，一个for循环遍历数组元素，第二个for循环更新数组。

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

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

/**
* 时间复杂度：O(n)
* 空间复杂度：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;
    }
}


//相向双指针方法，基于元素顺序可以改变的题目描述改变了元素相对位置，确保了移动最少元素
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;
    }
}

有序数组的平方

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

链接：https://leetcode.cn/problems/squares-of-a-sorted-array/

思路

因为是一个有序的数组，虽然说元素可以为负，平方后的值可能比正数的平方大，但是其最值永远是在数组的两端（绝对值大小），因此可以考虑双指针法 i 指向起始位置，j 指向终止位置。

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

滑动窗口

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

题目：【长度最小的子数组】：https://leetcode.cn/problems/minimum-size-subarray-sum/

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

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

在暴力解法中，是一个for循环滑动窗口的起始位置，一个for循环为滑动窗口的终止位置，用两个for循环完成了一个不断搜索区间的过程。

class Solution {//暴力解发，不建议
    public int minSubArrayLen(int target, int[] nums) {
        int temp = 0;
        int min = nums.length+1;
        
        for(int i = 0;i<nums.length;i++){
            int cur = nums[i];
            if(cur == target){
                return 1;
            }
            for(int j = i+1;j<nums.length;j++){
                cur += nums[j];
                if(cur == target){
                    temp = j+1-i;
                    if(temp<min){
                        min = temp;
                    }
                    break;
                }else if(cur>target){
                    break;
                }
            }
        }
        return min == nums.length+1? 0:min;
    }
}

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

class Solution {

    // 滑动窗口
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0;
        int sum = 0;
        int result = Integer.MAX_VALUE;
        for (int right = 0; right < nums.length; right++) {
            sum += nums[right];
            while (sum >= target) {
                result = Math.min(result, right - left + 1);
                sum -= nums[left++];//这里体现出滑动窗口的精髓之处，不断变更i(子序列的起始位置)。
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

为什么时间复杂度是O(n)？不要以为for里放一个while就以为是O(n^2)啊，主要是看每一个元素被操作的次数，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n 也就是O(n)。

螺旋矩阵

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

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

这道题目可以说在面试中出现频率较高的题目，本题并不涉及到什么算法，就是模拟过程，但却十分考察对代码的掌控能力。

循环不变量原则每次循环的初始点都是在主对角线上！！！模拟顺时针画矩阵的过程:

填充上行从左到右

填充右列从上到下

填充下行从右到左

填充左列从下到上

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;//j 表示上行和下行；i表示右行和左行

        //分析：n = 3，转1圈；n = 4，转2圈；n = 5，转2圈；n = 6，转3圈；
        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--) {//此时 j 已经在 上行的最右边，因此往左遍历
                res[i][j] = count++;
            }

            // 模拟左侧从下到上
            for (; i >= loop; i--) {
                res[i][j] = count++;
            }
            start++;
        }
        //对于n为奇数，中心数 = count
        if (n % 2 == 1) {
            res[start][start] = count;
        }

        return res;
    }
}

桶思想

给你一个数组 nums，对于其中每个元素 nums[ i ]，请你统计数组中比它小的所有数字的数目。换而言之，对于每个 nums[i] 你必须计算出有效的 j 的数量，其中 j 满足 j != i 且 nums[j] < nums[i] 。以数组形式返回答案。

链接：https://leetcode.cn/problems/how-many-numbers-are-smaller-than-the-current-number

输入：nums = [8,1,2,2,3]

输出：[4,0,1,1,3]

解释：

对于 nums[0]=8 存在四个比它小的数字：（1，2，2 和 3）。

对于 nums[1]=1 不存在比它小的数字。

对于 nums[2]=2 存在一个比它小的数字：（1）。

对于 nums[3]=2 存在一个比它小的数字：（1）。

对于 nums[4]=3 存在三个比它小的数字：（1，2 和 2）。

思路：

首先能想到的就是暴力解法，通过两个 for 循环遍历，但是时间复杂度为 O(n^2);

优化：桶思想。

首先先定义一排桶，每个桶里面的值arr[ n ]就是用来存放数字 n 出现的个数

遍历 nums，初始化 arr

通过累加数组 arr，此时下标代表出现过的数字n，里面的内容代表小于等于n的个数，也就是下一数字的数组中比它小的数字的数目。

遍历取出对应的桶中的数据。

class Solution {
    public int[] smallerNumbersThanCurrent(int[] nums) {
        int[] arr = new int[101] ;
        for(int num : nums){
            arr[num] += 1;
        }
        for(int i = 1;i< arr.length;i++){
            arr[i] += arr[i-1];
        }
        for(int i = 0;i<nums.length;i++){
            nums[i] = nums[i] != 0? arr[nums[i]-1] : 0;//注意，当有0 的时候，需要判断，不然索引越界
        }
        return nums;
    }
}

双指针法

有效的山脉数组

给定一个整数数组 arr，如果它是有效的山脉数组就返回 true，否则返回 false。

让我们回顾一下，如果 A 满足下述条件，那么它是一个山脉数组：

arr.length >= 3

在 0 < i < arr.length - 1 条件下，存在 i 使得：

arr[0] < arr[1] < ... arr[i-1] < arr[i]

arr[i] > arr[i+1] > ... > arr[arr.length - 1]

class Solution {
    public boolean validMountainArray(int[] arr) {
        int len = arr.length;
        if(len < 3){
            return false;
        }
        int left = 0;
        int right = arr.length-1;
        while((--len)!= 0){
            if(arr[left] < arr[left+1]){ //不能是等号，因为不是山脉数组
                left++;
            }else if(arr[right] < arr[right-1]){
                
                right--;
            }
          
        }

        if(left == 0|| right == arr.length-1){
            return false;
        }
        if(right == left){
            return true;
        }else{
            return false;
        }
    }
}