算法沉淀——二分查找（leetcode真题剖析）

最新推荐文章于 2024-04-30 20:06:58 发布
最新推荐文章于 2024-04-30 20:06:58 发布
阅读量1.2k 收藏 40
点赞数 43
分类专栏： 算法沉淀 文章标签： 算法 leetcode 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kingxzq/article/details/135920443
版权

在这里插入图片描述

算法沉淀——二分查找

二分查找（Binary Search）是一种在有序数组中查找特定元素的算法。该算法的基本思想是通过每一次比较，将查找范围缩小一半，最终找到目标元素或者确定目标元素不存在。

二分查找的步骤：

  1. 初始化： 定义两个指针，left 和 right，分别指向数组的起始和结束位置。
  2. 循环条件： 在 left <= right 的条件下，执行以下步骤。
  3. 计算中间位置： 计算中间位置的索引 mid，可以使用 mid = (left + right) / 2 或者 mid = left + (right - left) / 2。这样可以防止整数溢出。
  4. 比较中间元素： 将目标元素与数组中间位置的元素进行比较。
    • 如果目标元素等于中间元素，查找成功，返回中间元素的索引。
    • 如果目标元素小于中间元素，说明目标元素可能在左半部分，更新 right = mid - 1。
    • 如果目标元素大于中间元素，说明目标元素可能在右半部分，更新 left = mid + 1。
  5. 重复步骤： 回到步骤 3，直到 left 大于 right，此时查找范围为空，表示目标元素不存在。

二分查找的优势：

  • 效率高： 由于每一次比较都将查找范围减半，二分查找的时间复杂度是 O(log n)，其中 n 是数组的长度。
  • 适用条件： 二分查找要求数组必须是有序的，但在有序数组中查找元素时，它是一种非常高效的算法。

二分查找的局限性：

  • 必须有序（大多数情况下）： 二分查找要求数组是有序的，如果数组是无序的，需要先进行排序。
  • 不适用于链表： 二分查找通常用于数组，对于链表结构，由于无法直接通过下标访问元素，不太适用。
  • 只能查找特定值： 二分查找主要用于查找特定值，对于查找范围不明确的情况，可能不太合适。

二分查找的应用场景：

  • 在有序数组中查找特定元素。
  • 寻找有序数组中的上下界。
  • 在数值范围内寻找满足条件的值。

二分查找基本模板

朴素版（适用于最基础的二分）

while(left<=right){
	int mid=left+(right-left)/2;
	if(条件)
		left=mid+1;
	else if(条件)
		right=mid-1;
	else
		return ...;
}

全能版（均可适用）

①查找左边界

while(left<right){
	int mid=left+(right-left)/2;
	if(条件)
		left=mid+1;
	else
		right=mid;
}

②查找右边界

while(left<right){
	int mid=left+(right-left+1)/2;
	if(条件)
		left=mid;
	else
		right=mid-1;
}

全能版的写法需要根据不同的情况做出相应改变，比如这里的中间值为什么要+1再除，是因为最下面的条件mid-1,如果没有-1，那么上面也不需要+1，这样做是为了防止进入死循环，这个模板仅供参考，切勿死记硬背，实践出真知，适合自己的才最重要。

01.二分查找

题目链接：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

思路

这里就是最基础的朴素二分，我们直接写上去就可以了，不熟悉二分最好自己动手写一遍，对后面的二分题就会有更深入的了解，打牢基础。

  1. 初始化两个指针 left 和 right 分别指向数组的起始位置和结束位置。
  2. 在 while 循环中，通过计算中间位置 mid（避免整数溢出的写法），对比中间元素与目标元素的大小关系，从而缩小查找范围。
    • 如果 nums[mid] > target，说明目标元素可能在左半部分，更新 right = mid - 1。
    • 如果 nums[mid] < target，说明目标元素可能在右半部分，更新 left = mid + 1。
    • 如果 nums[mid] == target，找到目标元素，返回 mid。
  3. 循环直到 left 大于 right，此时查找范围为空，返回 -1 表示目标元素不存在。

代码

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left=0,right=nums.size()-1;
        while(left<=right){
            int mid = left+(right-left)/2;
            if(nums[mid]>target) right=mid-1;
            else if(nums[mid]<target) left=mid+1;
            else return mid;
        }
        return -1;
    }
};

02.在排序数组中查找元素的第一个和最后一个位置

题目链接：https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array/

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：

输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

示例 3：

输入：nums = [], target = 0
输出：[-1,-1]

思路

这里题目指定时间复杂度为 O(log n) 的算法，说明就是要让我们使用二分的算法，这里需要注意两个问题，第一个是边界问题，避免死循环，第二就是这里找两个值，我们可以分成两个二分来找，这样我们可以将逻辑捋清楚，这里模板中左边界与有边界两个版本都能用上。

  1. 首先，判断数组是否为空，如果为空，则直接返回 {-1, -1}，表示目标元素不存在于数组中。
  2. 利用二分查找找到目标元素的起始位置，首先在数组中找到第一个大于等于 target 的元素的位置。这个过程通过维护两个指针 left 和 right，在循环中不断缩小查找范围，最终 left 的位置就是目标元素的起始位置。
  3. 如果找到的 nums[left] 不等于 target，说明目标元素不存在，返回 {-1, -1}。
  4. 如果找到了目标元素的起始位置 begin，则重置 left 和 right，利用二分查找找到目标元素的结束位置。在这一步中，找到第一个大于 target 的位置的前一个位置，即 right。
  5. 返回结果，即目标元素的起始位置和结束位置。

代码

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        if(!nums.size()) return {-1,-1};

        int left=0,right=nums.size()-1;
        while(left<right){
            int mid=left+(right-left)/2;
            if(nums[mid]<target) left=mid+1;
            else right=mid;
        }

        if(nums[left]!=target) return {-1,-1};
        int begin=left;
        left=0,right=nums.size()-1;
        while(left<right){
            int mid=left+(right-left+1)/2;
            if(nums[mid]<=target) left=mid;
            else right=mid-1;
        }

        return {begin,right};
    }
};

03.搜索插入位置

题目链接：https://leetcode.cn/problems/search-insert-position/

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

示例 1:

输入: nums = [1,3,5,6], target = 5
输出: 2

示例 2:

输入: nums = [1,3,5,6], target = 2
输出: 1

示例 3:

输入: nums = [1,3,5,6], target = 7
输出: 4

思路

和上一题一样，题目指定时间复杂度为 O(log n) 的算法，说明就是要让我们使用二分的算法，这里我们直接使用左边界二分即可，注意边界问题，比如target值大于最后一个值，需要考虑。

  1. 初始化两个指针 left 和 right 分别指向数组的起始位置和结束位置。
  2. 在 while 循环中，通过计算中间位置 mid（避免整数溢出的写法），对比中间元素与目标元素的大小关系，从而缩小查找范围。
    • 如果 nums[mid] < target，说明目标元素可能在右半部分，更新 left = mid + 1。
    • 如果 nums[mid] >= target，说明目标元素可能在左半部分，更新 right = mid。
  3. 循环直到 left >= right，此时 left 就是插入位置，因为 left 所指的元素是第一个大于或等于 target 的元素。
  4. 最后判断 nums[left] 与 target 的关系：
    • 如果 nums[left] < target，则插入位置在 left + 1。
    • 否则，插入位置在 left。
  5. 返回插入位置。

代码

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int left=0,right=nums.size()-1;
        while(left<right){
            int mid = left+(right-left)/2;
            if(nums[mid]<target) left=mid+1;
            else right=mid;
        }
        if(nums[left]<target) return left+1;
        return left;
    }
};

04.x 的平方根

题目链接：https://leetcode.cn/problems/sqrtx/

给你一个非负整数 x ，计算并返回 x 的 算术平方根 。

由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。

**注意：**不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

示例 1：

输入：x = 4
输出：2

示例 2：

输入：x = 8
输出：2
解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。

思路

这里我们使用二分是在暴力循环的基础上改进而来的，需要注意的是边界问题和溢出问题

  1. 首先，判断 x 的值，如果小于 1，则直接返回 0，因为在非负整数范围内不存在小于 1 的平方根。
  2. 初始化两个指针 left 和 right，分别指向 1 和 x。
  3. 在 while 循环中，通过计算中间位置 mid（使用 (right - left + 1) / 2 避免整数溢出），对比中间元素的平方与 x 的大小关系，从而缩小查找范围。
    • 如果 mid * mid <= x，说明目标平方根可能在右半部分，更新 left = mid。
    • 如果 mid * mid > x，说明目标平方根可能在左半部分，更新 right = mid - 1。
  4. 循环直到 left >= right，此时 left 或 right 就是平方根的整数部分。
  5. 返回 right。

代码

class Solution {
public:
    int mySqrt(int x) {
        if(x<1) return 0;
        int left=1,right=x;
        while(left<right){
            long long mid = left+(right-left+1)/2;
            if(mid*mid<=x) left=mid;
            else right=mid-1;
        }
        return right;
    }
};

05.山脉数组的峰顶索引

题目链接：https://leetcode.cn/problems/peak-index-in-a-mountain-array/

符合下列属性的数组 arr 称为 山脉数组 ：

  • arr.length >= 3
  • 存在i（0 < i < arr.length - 1）使得：
    • arr[0] < arr[1] < ... arr[i-1] < arr[i]
    • arr[i] > arr[i+1] > ... > arr[arr.length - 1]

给你由整数组成的山脉数组 arr ，返回满足 arr[0] < arr[1] < ... arr[i - 1] < arr[i] > arr[i + 1] > ... > arr[arr.length - 1] 的下标 i 。

你必须设计并实现时间复杂度为 O(log(n)) 的解决方案。

示例 1：

输入：arr = [0,1,0]
输出：1

示例 2：

输入：arr = [0,2,1,0]
输出：1

示例 3：

输入：arr = [0,10,5,2]
输出：1

思路

看到这题很多并不会想到使用二分去做，因为概念里写的使用二分一定要有序，但是这里是可以使用二分的思想来做这道题的，所以我们要将思路打开，根据题意这里山顶不会是左右的边界值，所以这里我们只要使用二分找出数组的最大值就行了

  1. 初始化两个指针 left 和 right，分别指向二分的起始位置和结束位置（边界不需要考虑）。
  2. 在 while 循环中，通过计算中间位置 mid（使用 (right - left) / 2 避免整数溢出），对比中间元素与其右侧元素的大小关系，从而缩小查找范围。
    • 如果 arr[mid] < arr[mid + 1]，说明峰值可能在右半部分，更新 left = mid + 1。
    • 如果 arr[mid] >= arr[mid + 1]，说明峰值可能在左半部分，更新 right = mid。
  3. 循环直到 left >= right，此时 left 或 right 就是山脉数组的峰值。
  4. 返回 right。

这个算法的核心思想是通过二分查找，在山脉数组中找到峰值的索引。在山脉数组中，峰值是指一个位置左侧的元素严格单调递增，右侧的元素严格单调递减的位置。因此，通过比较中间元素与其右侧元素的大小关系，可以缩小查找范围，最终找到峰值的位置。

代码

class Solution {
public:
    int peakIndexInMountainArray(vector<int>& arr) {
        int left=1,right=arr.size()-2;
        while(left<right){
            int mid = left+(right-left)/2;
            if(arr[mid]<arr[mid+1]) left=mid+1;
            else right=mid;
        }
        return right;
    }
};

06.寻找峰值

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

峰值元素是指其值严格大于左右相邻值的元素。

给你一个整数数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。

你可以假设 nums[-1] = nums[n] = -∞ 。

你必须实现时间复杂度为 O(log n) 的算法来解决此问题。

示例 1：

输入：nums = [1,2,3,1]
输出：2
解释：3 是峰值元素，你的函数应该返回其索引 2。

示例 2：

输入：nums = [1,2,1,3,5,6,4]
输出：1 或 5 
解释：你的函数可以返回索引 1，其峰值元素为 2；
     或者返回索引 5， 其峰值元素为 6。

思路

基本和上一题的二分思想是一致的，但是这里需要考虑边界问题，因此不能直接去除首尾。

  1. 初始化两个指针 left 和 right，分别指向数组的起始位置和结束位置。
  2. 在 while 循环中，通过计算中间位置 mid（使用 (right - left) / 2 避免整数溢出），对比中间元素与其右侧元素的大小关系，从而缩小查找范围。
    • 如果 nums[mid] < nums[mid + 1]，说明峰值可能在右半部分，更新 left = mid + 1。
    • 如果 nums[mid] >= nums[mid + 1]，说明峰值可能在左半部分，更新 right = mid。
  3. 循环直到 left >= right，此时 left 或 right 就是无序数组的峰值。
  4. 返回 left。

代码

class Solution {
public:
    int findPeakElement(vector<int>& nums) {
        int left=0,right=nums.size()-1;
        while(left<right){
            int mid = left+(right-left)/2;
            if(nums[mid]<nums[mid+1]) left=mid+1;
            else right=mid;
        }
        return left;
    }
};

07.寻找旋转排序数组中的最小值

题目链接：https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array/

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：

  • 若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
  • 若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]

注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。

给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。

你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [3,4,5,1,2]
输出：1
解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。

示例 2：

输入：nums = [4,5,6,7,0,1,2]
输出：0
解释：原数组为 [0,1,2,4,5,6,7] ，旋转 3 次得到输入数组。

示例 3：

输入：nums = [11,13,15,17]
输出：11
解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。

思路

这里我们使用二分法使用中间值与最右边的值相比较，若中间值大，说明最小值一定在右边，反之在左边，这里使用二分法不用考虑数组旋转了几次。

  1. 初始化两个指针 left 和 right，分别指向数组的起始位置和结束位置。
  2. 记录数组最右侧元素的值为 x，作为旋转的轴。这个轴元素是数组的最小元素。
  3. 在 while 循环中，通过计算中间位置 mid（使用 (right - left) / 2 避免整数溢出），对比中间元素与 x 的大小关系，从而缩小查找范围。
    • 如果 nums[mid] > x，说明最小元素可能在右半部分，更新 left = mid + 1。
    • 如果 nums[mid] <= x，说明最小元素可能在左半部分或就是 mid 位置，更新 right = mid。
  4. 循环直到 left >= right，此时 left 或 right 就是数组中的最小元素所在的位置。
  5. 返回 nums[left]。

代码

class Solution {
public:
    int findMin(vector<int>& nums) {
        int left=0,right=nums.size()-1;
        int x=nums[right];
        while(left<right){
            int mid=left+(right-left)/2;
            if(nums[mid]>x) left=mid+1;
            else right=mid;
        }
        return nums[left];
    }
};

08.LCR 173. 点名

题目链接：https://leetcode.cn/problems/que-shi-de-shu-zi-lcof/

某班级 n 位同学的学号为 0 ~ n-1。点名结果记录于升序数组 records。假定仅有一位同学缺席，请返回他的学号。

示例 1:

输入: records = [0,1,2,3,5]
输出: 4

示例 2:

输入: records = [0, 1, 2, 3, 4, 5, 6, 8]
输出: 7

思路

这道题其实有多种解法，我们使用二分解决可以效率非常高，这里只需要注意边界问题，即最大学号缺席。

  1. 初始化两个指针 left 和 right，分别指向数组的起始位置和结束位置。
  2. 在 while 循环中，通过计算中间位置 mid（使用 (right - left) / 2 避免整数溢出），对比中间元素 records[mid] 与 mid 的大小关系，从而缩小查找范围。
    • 如果 records[mid] == mid，说明漏考勤的学生可能在右半部分，更新 left = mid + 1。
    • 如果 records[mid] != mid，说明漏考勤的学生可能在左半部分或就是 mid 位置，更新 right = mid。
  3. 循环直到 left >= right，此时 left 或 right 就是漏考勤的学生的位置。
  4. 返回 right == records[right] ? right + 1 : right。

代码

class Solution {
public:
    int takeAttendance(vector<int>& records) {
        int left=0,right=records.size()-1;
        while(left<right){
            int mid = left + (right-left)/2;
            if(records[mid]==mid) left=mid+1;
            else right=mid;
        }

        return right==records[right]?right+1:right;
    }
};
爱学习的鱼佬
关注
  • 43
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 38
    评论
专栏目录
算法模板（Java版）——leetcode刷题与复习指南.zip
01-13
Java是一种高性能、跨平台的面向对象编程语言。它由Sun Microsystems（现在是Oracle Corporation）的James Gosling等人在1995年推出，被设计为一种简单、健壮、可移植、多线程、动态的语言。Java的主要特点和优势包括以下几个方面： 跨平台性（Write Once, Run Anywhere）： Java的代码可以在不同的平台上运行，只需编写一次代码，就可以在任何支持Java的设备上执行。这得益于Java虚拟机（JVM），它充当了代码和底层硬件之间的中介。 面向对象： Java是一种纯粹的面向对象编程语言，支持封装、继承和多态等面向对象的概念。这使得Java编写的代码更加模块化、可维护和可扩展。 多线程支持： Java内置了对多线程的支持，允许程序同时执行多个任务。这对于开发需要高并发性能的应用程序（如服务器端应用、网络应用等）非常重要。 自动内存管理（垃圾回收）： Java具有自动内存管理机制，通过垃圾回收器自动回收不再使用的对象，使得开发者不需要手动管理内存，减轻了程序员的负担，同时也减少了内存泄漏的风险。
catwang01#Algorithm#Leetcode 704. 二分查找1
07-25
问题描述算法解法1: 左开右闭区间解法1：实现elif nums[mid] < target:elif nums[mid] > target:
二分查找的三种方法
小王学代码
12-29 2252
对于已经排好序的数组，快速的寻找到指定元素，并返回其下标，这个时候就有二分查找的妙用提示：以下是本篇文章正文内容，下面案例可供参考第二种和第三种实质上差不多，最后返回 l 或者 r 都可以，最经典的是第一种方法，第二种第三种更快一点。//要找的就是大于x的 如果满足的话 mid 在x左边缩小范围为 r=mid 【l，mid】}}}
【二分查找】有这一篇足够了
m0_58761900的博客
05-10 1万+
【二分查找】（折半查找）有这一篇足够了 1.二分查找是干啥的 2. 力扣中的一些练习题 2.1 二分查找 2.2 第一个错误的版本 2.3 搜索插入位置 2.4 在排序数组中查找元素第一个和最后一个位置 2.5x的平方根 2.6 有效的完全平方数 3.总结一下
二分查找算法题汇总整理
12-28
二分查找算法题汇总整理，以C++为主，主要针对leetcode算法题进行汇总。
二分查找--图文详解
iLoyo_的博客
07-01 2万+
二分查找也称折半查找，是在一组有序(升序/降序)的数据中查找一个元素，它是一种效率较高的查找方法。
【C语言】二分查找
...
08-01 1万+
在有序表中，每次都取中间元素作为比较的对象。 如果给中间值与给定值相等，则查找成功，返回该元素的下标/索引； 如果中间值大于给定值，则在中间值的右半区间继续查找； 如果中间值小于给定值，则在中间值的左半区间继续查找；........................
二分查找详解
weixin_62275996的博客
12-05 2761
🌈🌈😄😄 欢迎小伙伴来到茶色岛独家岛屿，本期会对二分查找进行详细的讲解，做好准备了么，那么开始吧。 🌲🌲🐴🐴
二分查找（折半查找）
热门推荐
zmeilin的博客
07-21 14万+
二分查找是一种算法，其输入是一个有序的元素列表（必须是有序的），如果查找的元素包含在列表中，二分查找返回其位置，否则返回NULL 比如说有一个1-100的数字，我随机的选择其中一个数字（假设为60），你需要以最少的次数猜到我所选择的数字，每次猜测后，我会告诉你大了，小了，对了。 假设你第一次从1开始猜，小了 第二次：2 小了 第三次：3 小了 …… 第五十九次：59小了 ...
查找算法：二分查找
weixin_47406709的博客
07-10 5万+
二分查找
Leetcode刷题手册 labuladong的算法小抄官方完整版（共 560 页）
06-19
算法 Leetcode刷题手册 labuladong的算法小抄官方完整版
leetcode 704 二分查找
06-24
虽然题目是很简单，但是对于细节进行了补充
05-二分查找.md
03-31
- 三大算法思维：贪心，二分，动态规划 - 常见数据结构 ## 注意事项 - 算法，有难度，轻耐心学习 - 不仅关注题目本身，更要关注知识点和解题思路 - 按顺序学习（本章课程按顺序设计的） ## 看几个面试题 列举几...
Codeforces Round 941 (Div. 2) （A~D）
weixin_61825750的博客
04-28 701
然后考虑若此时存在两个堆，那么对于Alice而言，其操作可以使得小的那个堆只剩下1，下一步Bob必须选1，然后Alice就胜利了。相反，若小的那个堆一开始就是1，那么Alice就输了。接下来推广到若干堆的情况：对于任意一方而言，若最小堆不是1，那么便可以控制胜利，于是我们只需要枚举到最小堆不是1的情况即可，然后看是谁在操作就是谁赢。思路：若要使得所有方格同色，关键在于四个角上的颜色，若对角上的颜色一样就能直接将所有格子变为同色。思路：首先处理 < k 的部分，我们可以通过二进制的思想来构造整数，例如。
算法训练营第十一天 | LeetCode 20 有效的括号、LeetCode 1047 删除字符串中的所有相邻重复项
qq_63149342的博客
04-27 118
注意用的是字符串数组作为输入，而我们要用int型进行计算，这时候就要用到一个string转int类型的库函数stoi函数，aoti是字符数组转int类型。一个是最后循环结束后要判断栈内存是否为空，一个是出栈时要判断栈是否为空，总的来说是考验对于栈内存空间的掌控吧。这一题考栈的性质，相邻字符用未进栈的元素和进栈的元素进行模拟即可，相同且栈不为空即出栈，否则进栈，之后将栈内元素全部导入一个字符串，还要注意要写一个反转函数翻转下即可。LeetCode 1047 删除字符串中的所有相邻重复项。
Golang | Leetcode Golang题解之第56题合并区间
weixin_66442839的博客
04-28 450
Golang | Leetcode Golang题解之第56题合并区间
4/26发布发布：缺了好几次的作业，矩形法+二分法求下面方程根+顺序查找n+程序填空，补一下还有八九没做，炸8412 字不是干的，哈哈哈
2201_75637762的博客
04-26 1236
eps：用于定义逼近的精度，即当x1和x2的差小于eps时，认为找到了根。x1和x2：用于二分法的初始区间，这里选择的是[-10, 10]。y1和y2：分别是x1和x2处函数的值。这个程序通过二分法在一个给定的区间内寻找三次方程的根。它首先检查函数在区间端点的值的符号，然后使用二分法逐步缩小区间，直到找到满足精度要求的根或确定区间内没有根为止。okll测试数据：3 4 7 12 24 78 9 15 80 45第一次运行程序输入测试数据 12。
算法~本质
最新发布
sweet_Mary的博客
04-30 258
数据结构分为数组和链表，数据结构的目的是提升增删改查的效率。算法的本质是基于这两种数据结构进行高效穷举。2.如何聪明地穷举？--并查集/贪心/KMP）数组--二分搜索/双指针/滑动窗口/前缀+差分。二叉树系列（回溯算法+动态规划）eg.求二叉树最大深度。2. 分解问题计算答案。2.分解问题计算答案。eg.二叉树前缀遍历。
代码随想录算法训练营Day25 | 216.组合总和III、17.电话号码的字母组合 | Python | 个人记录向
Python基本算法
04-27 638
回溯算法：216.组合总和III、17.电话号码的字母组合。
c++ kmp算法字符匹配_LeetCode笔记：字符串匹配——KMP算法
05-12
KMP算法是一种字符串匹配算法，用于在一个文本串S内查找一个模式串P的出现位置。它的时间复杂度为O(n+m)，其中n为文本串的长度，m为模式串的长度。 KMP算法的核心思想是利用已知信息来避免不必要的字符比较。具体来说，它维护一个next数组，其中next[i]表示当第i个字符匹配失败时，下一次匹配应该从模式串的第next[i]个字符开始。 我们可以通过一个简单的例子来理解KMP算法的思想。假设文本串为S="ababababca"，模式串为P="abababca"，我们想要在S中查找P的出现位置。 首先，我们可以将P的每个前缀和后缀进行比较，得到next数组： | i | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | | --- | - | - | - | - | - | - | - | - | | P | a | b | a | b | a | b | c | a | | next| 0 | 0 | 1 | 2 | 3 | 4 | 0 | 1 | 接下来，我们从S的第一个字符开始匹配P。当S的第七个字符和P的第七个字符匹配失败时，我们可以利用next[6]=4，将P向右移动4个字符，使得P的第五个字符与S的第七个字符对齐。此时，我们可以发现P的前五个字符和S的前五个字符已经匹配成功了。因此，我们可以继续从S的第六个字符开始匹配P。 当S的第十个字符和P的第八个字符匹配失败时，我们可以利用next[7]=1，将P向右移动一个字符，使得P的第一个字符和S的第十个字符对齐。此时，我们可以发现P的前一个字符和S的第十个字符已经匹配成功了。因此，我们可以继续从S的第十一个字符开始匹配P。 最终，我们可以发现P出现在S的第二个位置。 下面是KMP算法的C++代码实现：

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 38
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱学习的鱼佬

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值