20240322&23&24_ArrayPractise

最新推荐文章于 2024-08-23 00:00:00 发布

Meleossi

最新推荐文章于 2024-08-23 00:00:00 发布

阅读量1.1k

点赞数 38

文章标签： java 开发语言 leetcode

本文链接：https://blog.csdn.net/m0_58068822/article/details/137028240

版权

本文介绍了几个编程题目，包括二分查找、移除元素、有序数组的平方、长度最小子数组和螺旋矩阵的生成，展示了在Java中如何使用不同的算法解决这些与数组操作相关的LeetCode问题。

摘要由CSDN通过智能技术生成

20240322&23&24_ArrayPractise

参考来源：代码随想录，leetcode

704. 二分查找

力扣题目链接(opens new window)

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

package Practise.ArrayPractice;

public class No_704 {//代码随想录:704.二分查找
    //给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target
    //写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
    public static void main(String[] args) {
        int[] nums = {1,2,3,4,7,9,10};
        System.out.println(search(nums,0));
    }
    static int search(int[] nums, int target){
            if(target < nums[0] || target>nums[nums.length - 1]){
                return -1;
            }
            int left = 0;
            int right = nums.length - 1;
            while (left <= right){
                int mid = left + ((right - left)>>1);
                if(nums[mid] == target){
                    return target;
                } else if (nums[mid] < target) {
                    left = mid + 1;
                } else if (nums[mid] > target) {
                    right = mid - 1;
                }
            }
        return -1;
    }
}

27. 移除元素

力扣题目链接(opens new window)

给你一个数组 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。

你不需要考虑数组中超出新长度后面的元素。

package Practise.ArrayPractice;

public class No_27 {
    /*
    给你一个数组 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。
    你不需要考虑数组中超出新长度后面的元素。
     */
    public static void main(String[] args) {
        int[] nums = {0,1,2,2,3,0,4,2};
        int val = 2;
//        System.out.println(removeElement1(nums,val));
        System.out.println(removeElement(nums,val));
    }
    public int removeElement1(int[] nums, int val) {//[3,2,2,3],有bug
        int size = nums.length;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == val){
                for (int j = i + 1; j < nums.length; j++) {
                    nums[j-1] = nums[j];
                }
                i--;
                size--;
            }
        }
        return size;
    }
    public static int removeElement(int[] nums, int val) {//快慢指针法
        int slowInd = 0;//3，2，2，3
        for (int fastInd = 0; fastInd < nums.length;fastInd++){
            if (nums[fastInd] != val){
                nums[slowInd] = nums[fastInd];
                slowInd++;
            }
        }
        return slowInd;
    }
}

977.有序数组的平方

力扣题目链接(opens new window)

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

package Practise.ArrayPractice;

import java.util.Arrays;

public class No_977 {
    /*
    给你一个按非递减顺序排序的整数数组 nums，返回 每个数字的平方组成的新数组，要求也按非递减顺序 排序。
    输入：nums = [-4,-1,0,3,10]
    输出：[0,1,9,16,100]
    解释：平方后，数组变为 [16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]
     */
    public static void main(String[] args) {
        int[] nums = {-4,-1,0,3,100};
        System.out.println(Arrays.toString(sortedSquares(nums)));
        System.out.println(Arrays.toString(sortedSquares1(nums)));
    }
    public static int[] sortedSquares1(int[] nums){//暴力法
        for (int i = 0; i < nums.length; i++) {
            nums[i] = nums[i] * nums[i];
        }
        for (int j = nums.length - 1; j >=1 ; j--) {
            for (int k = nums.length - 2; k >= 0 ; k--) {
                if (nums[k + 1] <= nums[k]){
                    int tmp = nums[k + 1];
                    nums[k + 1] = nums[k];
                    nums[k] = tmp;
                }
            }
        }
        return nums;
    }
    public static int[] sortedSquares(int[] nums){//双指针法,一定要非递减才行
        int[] res = new int[nums.length];
        int l = 0;
        int r = nums.length - 1;
        int k = nums.length - 1;
        while (l<=r){
            if(nums[l]*nums[l] > nums[r]*nums[r]){
                res[k] = nums[l]*nums[l];
                l++;
                k--;
            }else {
                res[k] = nums[r]*nums[r];
                r--;
                k--;
                }
        }
        return res;
    }
}

209.长度最小的子数组

力扣题目链接(opens new window)

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

示例：

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

提示：

1 <= target <= 10^9
1 <= nums.length <= 10^5
1 <= nums[i] <= 10^5

package Practise.ArrayPractice;

public class No_209 {
    public static void main(String[] args) {
    /*
    给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组
    并返回其长度。如果不存在符合条件的子数组，返回 0。
    示例：输入：s = 7, nums = [2,3,1,2,4,3]
    输出：2
    解释：子数组 [4,3] 是该条件下的长度最小的子数组。
     */
        int[] nums = {2,3,1,2,4,3};
        System.out.println(minSubArrayLen(7,nums));
    }
    public static int minSubArrayLen(int target, int[] nums) {//滑动窗口法
        int left = 0;
        int sum = 0;
        int res = Integer.MAX_VALUE;
        for (int right = 0; right < nums.length; right++) {
            sum += nums[right];
            while (sum >= target){
                res = Math.min(res,right - left + 1);//判断最小长度
                sum -= nums[left++];//精髓
//                left++;
            }
        }
        return (res ==Integer.MAX_VALUE ? 0 : res);
    }
}

59.螺旋矩阵II

力扣题目链接(opens new window)

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

示例:

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

package Practise.ArrayPractice;

import java.util.Arrays;

public class No_59 {
    /*
    给定一个正整数 n，生成一个包含 1到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。
    示例:
    输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]
     */
    public static void main(String[] args) {
        int n = 3;
        System.out.println(Arrays.deepToString(generateMatrix(n)));
    }

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