代码随想录Day1

最新推荐文章于 2026-08-15 11:04:49 发布

原创最新推荐文章于 2026-08-15 11:04:49 发布 · 932 阅读

10 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

代码随想录Day1

第一题 704. 二分查找

题目链接：https://leetcode.cn/problems/binary-search/
给定一个 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]之间。
看到题目第一时间我的想法是之前学习数据结构的时候对于二分的一些映像，但是有些模糊总而言之就是比较难下手
在看完代码随想录的讲解后我发现了这道题目的几个关键点
- 首先需要确定这个数组所采用的区间范围
  - 常见的范围有两种：
    
    左闭右开：[left,right)
    
    左闭右闭：[left，right]
- 以及需要确定while的循环条件是(left<right)还是(left<=right)
- 还有right是应该等于 nums.length还是nums.length-1

这里我采用左开右闭的区间来完成

package cn.LaoTeng.coder;
/**
 * 手撕二分查找
 * https://leetcode.cn/problems/binary-search/
 */
public class BinarySearch {
    class Solution {
        public int search(int[] nums, int target) {
            //采用左开右闭区间
            int left, right, middle;
            right = nums.length;
            left = 0;
            while (left < right) {
                middle = left + (right - left) / 2;
                if (nums[middle] > target) {
                    right = middle;
                } else if (nums[middle] < target) {
                    left = middle + 1;//此时target在区间[middle+1,right)中
                }else return middle;
            }
            //找不到target则返回-1
            return -1;
        }
    }
}

第二题 27. 移除元素

题目链接：https://leetcode.cn/problems/remove-element/

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

你不需要考虑数组中超出新长度后面的元素。
看到题目后我第一想法是通过Java的库函数来进行，但很明显违背了这道题目的本意，题目的本意应该是想让我们采用双指针法来实现一个复杂度为O(n)的仿库函数代码，当然这道题可以采用两个for循环的暴力解法，但复杂度太高这里就不提及了
这道题目的核心是需要理解题目中两个双指针的作用也就是 front 和 slow的作用
- frontIndex用来寻找新数组中的元素
- slowIndex用来指向更新新数组下标的位置

package cn.LaoTeng.coder;

/**
 * <a href="https://leetcode.cn/problems/remove-element/">...</a>
 */
public class RemoveElement {
    class Solution {
        public int removeElement(int[] nums, int val) {
            //采用快慢指针法进行元素删除
            //frontIndex用来寻找新数组中的元素，slowIndex用来指向更新新数组下标的位置
            int frontIndex = 0;
            int slowIndex = 0;
            for (frontIndex = 0; frontIndex < nums.length; frontIndex++) {
                //当nums[frontIndex]并不是val时则将该元素索引赋值给慢指针
                if (val != nums[frontIndex]) {
                    nums[slowIndex++] = nums[frontIndex];
                }
            }
            return slowIndex;
        }
    }
}

第三题 977.有序数组的平方

题目链接：https://leetcode.cn/problems/squares-of-a-sorted-array/
给你一个按非递减顺序排序的整数数组 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]
这道题比较直白的想法就是先对数组中的每个元素进行平方，然后再进行一个排序，这样做的复杂度是 O(nlogn)

这道题可以采用双指针的解法进行可以实现 O(n)的复杂度

双指针法

数组其实是有序的，只不过负数平方之后可能成为最大数了。

那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。

此时可以考虑双指针法了，i指向起始位置，j指向终止位置。

定义一个新数组result，和A数组一样的大小，让k指向result数组终止位置。

如果A[i] * A[i] < A[j] * A[j] 那么result[k--] = A[j] * A[j]; 。

如果A[i] * A[i] >= A[j] * A[j] 那么result[k--] = A[i] * A[i];

package cn.LaoTeng.coder;

/**
 * <a href="https://leetcode.cn/problems/squares-of-a-sorted-array/">...</a>
 */
public class SquaresOfSortedArray {
    class Solution {
        public int[] sortedSquares(int[] nums) {
            //采用双指针法
            int left = 0, right = nums.length - 1;
            //定义结果集
            int[] result = new int[nums.length];
            int k = result.length - 1;
            while (left <= right) {
                if (nums[left] * nums[left] > nums[right] * nums[right]) {
                    result[k--] = nums[left] * nums[left];
                    left++;
                } else {
                    result[k--] = nums[right] * nums[right];
                    right--;
                }
            }
            return result;
        }
    }
}

标签

#算法 #java #leetcode