代码随想录算法训练营第一天| 704. 二分查找，27. 移除元素

最新推荐文章于 2024-05-31 21:13:08 发布

WDR8965

最新推荐文章于 2024-05-31 21:13:08 发布

阅读量952

点赞数 23

分类专栏：代码随想录算法训练营33期文章标签：算法 leetcode java

本文链接：https://blog.csdn.net/qq_42973684/article/details/136516995

版权

代码随想录算法训练营33期专栏收录该内容

53 篇文章 2 订阅

订阅专栏

题目与题解

参考资料：数组理论基础

704. 二分查找

题目链接：704. 二分查找

代码随想录题解：704. 二分查找

视频讲解：

手把手带你撕出正确的二分法 | 二分查找法 | 二分搜索法 | LeetCode：704. 二分查找_哔哩哔哩_bilibili

解题思路：

二分法属于算法题中的基础，原理很简单，在一个已经排序且无重复元素的序列中查找一个给定值，只需要设置高低两个指针，每次用两个指针中间的值和目标值对比，如果目标值比中间值大，则目标值在中间指针和高指针之间；如果目标值比中间值小，则目标值在低指针和中间指针之间；如果找到目标，则返回中间指针所在。

初次解题通过的代码如下：

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

看完代码随想录之后的想法

题目的思路非常容易想到，但实现起来确实如随想录解答所说，对区间的定义没有想清楚。不仅是这道题，许多需要考虑边界条件的问题都很容易出错。

Tips：

如果区间是左闭右闭，那么就需要考虑low == high的情况，此时high = mid - 1

如果区间是左闭右开，low 一定不等于 high，此时high = mid

代码细节
- 为了防止溢出，最好用low + (high - low)/2 代替 (low + high)/2
- 除以2可以用右移符号 >> 1代替
- 为提高算法效率，可以在一开始加上简单的前提条件避免极端情况

// 避免当 target 小于nums[0] nums[nums.length - 1]时多次循环运算
        if (target < nums[0] || target > nums[nums.length - 1]) {
            return -1;
        }

遇到的困难

第一次写的时候，没有考虑区间的问题，用了low < high作为条件，但是high = mid - 1，于是就华丽丽的出错了。

还有就是很久不从头写代码，在Java中一般都习惯用List方法，突然要用数组类型有点不记得用法，后面题目做多了应该就习惯了。

27. 移除元素

题目链接：27. 移除元素

代码随想录题解：27. 移除元素

视频讲解：

数组中移除元素并不容易！ | LeetCode：27. 移除元素_哔哩哔哩_bilibili

解题思路

数组相关的题，想要提高效率，要么是空间换时间，要么是时间换空间。

首先，最容易想到的就是暴力方法，额外申请一个大小为n的新数组，遍历原数组，将符合要求的数塞入新数组，那么算法空间复杂度为n，时间复杂度为n。

但是题目明确要求，只能原地修改数组，那么就只能用当前数组修改元素，最简单的暴力方法是使用两层for循环，当遍历到的元素等于目标值，则把该元素后面的所有元素往前挪一格，这样时间复杂度就是n2。

如果想将时间复杂度降到n，则要考虑如何在每次循环判断时，只修改少量元素。由于元素的顺序可以修改，那么，可以设置前后两个指针，将当前等于val的元素与后指针指向的元素交换，并将后指针向前挪一格，直到循环到前后指针相遇。

初次解题结果如下：

class Solution {
    public int removeElement(int[] nums, int val) {
		// 暴力法
		int result = nums.length;
		int i = 0;
		while (i < result) {
			if (val == nums[i]) {
				result--;
				for (int j = i; j < result; j++) {
					nums[j] = nums[j+1];
				}
			} else {
				i++;
			}
		}
 		return result;
    }
}

class Solution {
    public int removeElement(int[] nums, int val) {
		// 双指针法之交换
		int i = 0, j = nums.length - 1;
		int result = nums.length;
		while (i <= j) {
			if (val == nums[i]) {
				int temp = nums[i];
				nums[i] = nums[j];
				nums[j] = temp;
				j--;
			} else {
				i++;
			}
		}
		return i;
    }
}

看完代码随想录之后的想法

最优的快慢指针方法比我的交换法减少了交换的步骤，非常有巧思，既节约了时间，又节约了空间。但是感觉不容易想到，属于看过就会，不看就忘的方法，根本原因还是自己不太理解。

我先尝试看了思路以后自己写，但是不是结果出错，就是边界溢出，纯属没想好瞎碰。快慢指针的关键在于理解两个指针的用处：快指针就是用来遍历数组的，而慢指针用来表示更新数组的下标。换个角度想，结合一开始想到的O(n)空间复杂度的暴力算法，慢指针可以理解为一个新数组的下标，只不过不需要开辟额外的空间，而是直接用新数组覆盖了旧的数组。这种方法还有一个好处：更新后的数组除了去除掉的元素外，顺序不变。

欣赏一下优雅的快慢指针解法：

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