java算法实现704二分查找27移除元素_day1

最新推荐文章于 2024-10-10 09:56:47 发布

Yearningforwood

最新推荐文章于 2024-10-10 09:56:47 发布

阅读量66

点赞数

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

本文链接：https://blog.csdn.net/Yearningforwood/article/details/133839064

版权

算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

今日任务

数组理论基础，704. 二分查找，27. 移除元素

数组基础

C++中二维数组在地址空间上是连续的。

而Java是没有指针的，同时也不对程序员暴露其元素的地址，寻址操作完全交给虚拟机。

所以看不到每个元素的地址情况，我做一个实验。

public static void test_arr() {
    int[][] arr = {{1, 2, 3}, {3, 4, 5}, {6, 7, 8}, {9,9,9}};
    System.out.println(arr[0]);
    System.out.println(arr[1]);
    System.out.println(arr[2]);
    System.out.println(arr[3]);
}

输出的地址是

[I@7852e922
[I@4e25154f
[I@70dea4e
[I@5c647e05

这里的数值也是16进制，这不是真正的地址，而是经过处理过后的数值了，我们也可以看出，二维数组的每一行头结点的地址是没有规则的，更谈不上连续。

所以Java的二维数组可能是如下排列的方式：

算法通关数组3

704_二分查找

题目链接：704. 二分查找 - 力扣（LeetCode）

给定一个 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]之间。

思路

题目中提到数组为有序数组且无重复元素时，就要考虑二分法。

原因：

二分法的前提是有序

一旦有重复元素，使用二分法返回的元素下标不唯一

边界条件

是 while(left < right) 还是 while(left <= right)？，到底是right = middle，还是right = middle - 1呢？

要想解决如上问题，需要想清楚区间的定义，区间的定义就是不变量。

区间的定义：一般为两种，左闭右闭即[left, right]，或者左闭右开即[left, right)。

循环不变量规则：在while寻找中每一次边界的处理都要坚持根据区间的定义来操作。

[left, right]

当我们采用闭区间来理解的时候，通过[ 1 , 1 ]这个例子，我们可以发现当左边界等于右边界的时候是有意义的，它决定了下面的写法：

int left = 0,right = nums.length - 1 因为是闭区间，左右边界都可以参与计算
while (left <= right) 要使用 <= ，因为left == right有意义
if (nums[middle] > target) right 要赋值为 middle - 1，因为右边是闭区间，上轮循环的右边界（下轮循环的左边界）已经参与过if中的计算了

代码如下：

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

[left, right）

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

有如下三点：

int left = 0,right = nums.length 因为是左闭右开区间，右边界不参与计算
while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，直接排除nums[middle]去左区间继续寻找，而寻找区间是左闭右开区间，所以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;
    }
}

27_移除元素

题目链接：27. 移除元素 - 力扣（LeetCode）

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

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

思路

暴力解法

多余的元素，删掉不就得了------------吗？

要知道数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖。

这个题目暴力的解法就是两层for循环，一个for循环遍历数组元素，第二个for循环更新数组。

代码如下：

class Solution {
    public int removeElement(int[] nums, int val) {
        int len = nums.length;
        for (int i = 0;i < len;i++){
            if (nums[i] == val){
                for (int j = i + 1; j < len; j++){
                    nums[j-1] = nums[j];
                }
                i--; // 因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
                len--;
            }
        }
        return len;
    }
}

请注意细节：

每删除一个元素都会影响循环次数，所以循环次数的定义要随着删除而减减
for (int j = i + 1; j < len; j++) nums[j-1] = nums[j]; 熟悉这种写法，如果采用 nums[j] = nums[j+1];的方式容易出现数组越界。
每删除一次数据，i都要退回一下

双指针法

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

双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组、链表、字符串等操作的面试题，都使用双指针法。

定义快慢指针

快指针：寻找新数组的元素，新数组就是不含有目标元素的数组
慢指针：指向更新新数组下标的位置

注意以下实现方法并没有改变元素的相对位置！

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

难理解的点：

为什么是nums[fastIndex] != val；因为只有当这个条件不满足的时候，是遇到了需要删除的元素了，这时候什么都不要做，就把快指针后移，慢指针不动，就可以了，在下一重快指针不指向要删除元素的循环里会让快指针所指向的非删除数赋值给慢指针指向的要删除的数
简单来说，正常的流程就是一直进行快指针赋值给慢指针的动作，而遇到要删除的数后，令快慢指针隔开，接着执行快指针赋值给慢指针的动作