数组部分的算法

椰皮糖

已于 2023-05-22 15:41:44 修改

阅读量39

点赞数 1

分类专栏： LeetCode刷题文章标签： leetcode 算法数据结构 java 学习

于 2023-05-19 14:39:39 首次发布

本文链接：https://blog.csdn.net/shencanggang/article/details/130766143

版权

LeetCode刷题专栏收录该内容

4 篇文章 0 订阅

订阅专栏

704.二分查找

力扣

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

示例 1:

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

示例 2:

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

提示：

你可以假设 nums 中的所有元素是不重复的。
n 将在 [1, 10000]之间。
nums 的每个元素都将在 [-9999, 9999]之间。

思路及算法：

这道题目的告诉我们数组为有序数组，同时还强调数组中无重复元素，当看到题目描述满足如上条件的时候，想到了可以用二分法进行查找。

class Solution {
    public int search(int[] nums, int target) {
         int left = 0;
         // 定义target在左闭右闭的区间里，[left, right]
        int right = nums.length - 1; 
        // 当left==right，区间[left, right]依然有效，所以用 <=
        while (left <= right) { 
            // 防止溢出 等同于(left + right)/2
            int middle = left + ((right - left) / 2);
            if (nums[middle] > target) {
                // target 在左区间，所以[left, middle - 1]
                right = middle - 1; 
            } else if (nums[middle] < target) {
                // target 在右区间，所以[middle + 1, right]
                left = middle + 1; 
            } else { // nums[middle] == target
                // 数组中找到目标值，直接返回下标
                return middle; 
            }
        }
        // 未找到目标值
        return -1;
    }
}

27. 移除元素

力扣

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

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

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

思路及算法：

数组元素原地移除、o(1)额外空间，可以考虑双指针，指针1记录记录无重复元素的最后位置，指针2记录即将要处理的元素最前位置。如果指针2的元素和val相等则跳过，继续处理下一个元素。如果不相同就将指针2指向的元素移动到指针1所在位置，指针1向前移动1位。

class Solution {
    public int removeElement(int[] nums, int val) {
        //指针1 res 记录无重复元素的最后位置
        int res = 0;
        //指针2 i 记录即将要处理的元素最前位置  
        for (int i = 0; i < nums.length; i++) {
             //nums[i] 不为val，
            if (nums[i] != val) {
                //需要将nums[i]移动到nums[res],
                nums[res] = nums[i];
                //res 向前移动1位
                res++;
            }
        }
         //返回指针1的位置
        return res;
    }
}

977.有序数组的平方

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

思路及算法：

法一：暴力排序，直接求每个数平方之后排个序，代码如下。

class Solution {
    public int[] sortedSquares(int[] nums) {
        int[] ans = new int[nums.length];
        for (int i = 0; i < nums.length; ++i) {
            ans[i] = nums[i] * nums[i];
        }
        Arrays.sort(ans);
        return ans;
    }
}

法二：考虑到提供的数组是有序的，负数平方之后可能成为最大数，所以平方后的最大值只可能在数组首尾，所以，我们可以利用这点，使用双指针法，比较数组头尾元素，大的插入平方数组的最后一个位置，小的进行下一次比较，直到遍历结束。

class Solution {
    public int[] sortedSquares(int[] nums) {
        int right = nums.length - 1;
        int left = 0;
        int[] res = new int[nums.length];
        int index = res.length - 1;
        while (left <= right) {
            if (nums[left] * nums[left] > nums[right] * nums[right]) {
                // 正数的相对位置是不变的， 需要调整的是负数平方后的相对位置
                res[index--] = nums[left] * nums[left];
                ++left;
            } else {
                res[index--] = nums[right] * nums[right];
                --right;
            }
        }
        return res;
    }
}