Leetcode_入门_二分查找

最新推荐文章于 2024-08-10 22:52:22 发布
最新推荐文章于 2024-08-10 22:52:22 发布
阅读量198 收藏
点赞数
分类专栏： leetcode入门 文章标签： leetcode c++ 二分法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43674414/article/details/107432141
版权

Leetcode_入门_二分查找

1、求开方

1）题目要求

实现 int sqrt(int x) 函数。

计算并返回 x 的平方根，其中 x 是非负整数。

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

示例 1:

输入: 4
输出: 2
示例 2:

输入: 8
输出: 2
说明: 8 的平方根是 2.82842…,
由于返回类型是整数，小数部分将被舍去。

2）我的解法

c++

class Solution {
public:
    int mySqrt(int x) {
        long l=0,r=x;
        long m=0;
        while(l<=r)
        {
            m=(l+r)/2;
            if(m*m==x||(m*m<x&&(m+1)*(m+1)>x))return m;
            else if(m*m<x)l=m+1;
            else r=m-1;
        }
        return m;
    }
};

3）其他解法

方法一：袖珍计算器算法
在这里插入图片描述

class Solution {
public:
    int mySqrt(int x) {
        if (x == 0) {
            return 0;
        }
        int ans = exp(0.5 * log(x));
        return ((long long)(ans + 1) * (ans + 1) <= x ? ans + 1 : ans);
    }
};

方法二：二分查找

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

作者：LeetCode-Solution
链接：link
来源：力扣（LeetCode）

方法三：牛顿迭代
在这里插入图片描述

class Solution {
public:
    int mySqrt(int x) {
        if (x == 0) {
            return 0;
        }

        double C = x, x0 = x;
        while (true) {
            double xi = 0.5 * (x0 + C / x0);
            if (fabs(x0 - xi) < 1e-7) {
                break;
            }
            x0 = xi;
        }
        return int(x0);
    }
};

作者：LeetCode-Solution
链接：link
来源：力扣（LeetCode）

4）自己的优化代码

c++

class Solution {
public:
    int mySqrt(int x) {
        long l=0,r=x;
        long m=0;
        while(l<=r)
        {
            m=(l+r)/2;
            if(m*m==x||(m*m<x&&(m+1)*(m+1)>x))return m;
            else if(m*m<x)l=m+1;
            else r=m-1;
        }
        return m;
    }
};

5）学到的东西

牛顿迭代法

二分查找法

C++:fabs()为求浮点数的绝对值
abs()为求整数的绝对值

2、大于给定元素的最小元素（744、Easy）

1）题目要求

给你一个排序后的字符列表 letters ，列表中只包含小写英文字母。另给出一个目标字母 target，请你寻找在这一有序列表里比目标字母大的最小字母。

在比较时，字母是依序循环出现的。举个例子：

如果目标字母 target = ‘z’ 并且字符列表为 letters = [‘a’, ‘b’]，则答案返回 ‘a’

示例：

输入:
letters = [“c”, “f”, “j”]
target = “a”
输出: “c”

输入:
letters = [“c”, “f”, “j”]
target = “c”
输出: “f”

输入:
letters = [“c”, “f”, “j”]
target = “d”
输出: “f”

输入:
letters = [“c”, “f”, “j”]
target = “g”
输出: “j”

输入:
letters = [“c”, “f”, “j”]
target = “j”
输出: “c”

输入:
letters = [“c”, “f”, “j”]
target = “k”
输出: “c”

提示：

letters长度范围在[2, 10000]区间内。
letters 仅由小写字母组成，最少包含两个不同的字母。
目标字母target 是一个小写字母。

2）我的解法

c++

class Solution {
public:
    char nextGreatestLetter(vector<char>& letters, char target) {
        int l=0,r=letters.size()-1,mid=-1;
        char result=' ';
          while(l<=r)
          {
              mid=(l+r)/2;
              if(letters[mid]>target){result=letters[mid];r=mid-1;}
              else l=mid+1;
          }
          if(result==' ')return letters[0];
          else return result;
    }
};

3）其他解法

方法一：记录存在的字母
算法：

我们可以扫描 letters 记录字母是否存在。我们可以用大小为 26 的数组或者 Set 来实现。
然后，从下一个字母（从比目标大一个的字母开始）开始检查一下是否存在。如果有的话则是答案。


class Solution {
    public char nextGreatestLetter(char[] letters, char target) {
        boolean[] seen = new boolean[26];
        for (char c: letters)
            seen[c - 'a'] = true;

        while (true) {
            target++;
            if (target > 'z') target = 'a';
            if (seen[target - 'a']) return target;
        }
    }
}

方法二：线性扫描
算法：
由于 letters 已经有序，当我们从左往右扫描找到比目标字母大字母则该字母就是答案。否则(letters 不为空)答案将是 letters[0]。

class Solution {
    public char nextGreatestLetter(char[] letters, char target) {
        for (char c: letters)
            if (c > target) return c;
        return letters[0];
    }
}

方法三：二分查找
算法：

如方法二一样，我们想要在有序数组中查找比目标字母大的最小字母，可以使用二分查找：让我们找到最右边的位置将 target 插入 letters 中，以便它保持排序。
二分查找分几轮进行，在每一轮中我们保持循环始终在区间 [lo，hi]。让 mi = (lo + hi) / 2。若 letters[mi] <= target，则我们修改查找区间为 [mi + 1, hi]，否则，我们修改为 [lo, mi]
最后，如果插入位置是最后一个位置 letters.length，则返回 letters[0]。这就是模运算的运用。

class Solution {
    public char nextGreatestLetter(char[] letters, char target) {
        int lo = 0, hi = letters.length;
        while (lo < hi) {
            int mi = lo + (hi - lo) / 2;
            if (letters[mi] <= target) lo = mi + 1;
            else hi = mi;
        }
        return letters[lo % letters.length];
    }
}

作者：LeetCode
链接：link
来源：力扣（LeetCode）

4）自己的优化代码

c++

class Solution {
public:
    char nextGreatestLetter(vector<char>& letters, char target) {
        int l=0,r=letters.size()-1,mid=-1;
        char result=' ';
          while(l<=r)
          {
              mid=(l+r)/2;
              if(letters[mid]>target){result=letters[mid];r=mid-1;}
              else l=mid+1;
          }
          if(result==' ')return letters[0];
          else return result;
    }
};

5）学到的东西

二分查找法

3、有序数组中的单一元素（540、Medium）

1）题目要求

给定一个只包含整数的有序数组，每个元素都会出现两次，唯有一个数只会出现一次，找出这个数。

示例 1:

输入: [1,1,2,3,3,4,4,8,8]
输出: 2
示例 2:

输入: [3,3,7,7,10,11,11]
输出: 10
注意: 您的方案应该在 O(log n)时间复杂度和 O(1)空间复杂度中运行

2）我的解法

c++

class Solution {
public:

     bool isfront(int mid,vector<int>& nums)
     {
         if(mid%2==0)
         {
             if(nums[mid]==nums[mid-1])return true;
             else return false;
         }
         else 
         {
             if(nums[mid]==nums[mid-1])return false;
             else return true;
         }
     }
    int singleNonDuplicate(vector<int>& nums) {
        int l=0,r=nums.size()-1,mid=-1;
        
        if(nums.size()==1)return nums[0];

        while(l<=r)
        {
            mid=(l+r)/2;
            if(mid==0&&nums[mid]!=nums[mid+1])break;
            else if(mid==nums.size()-1&&nums[mid]!=nums[mid-1])break;
            else if(nums[mid]!=nums[mid-1]&&nums[mid]!=nums[mid+1])break;
            else if(isfront(mid,nums))r=mid-1;
            else l=mid+1;
        }
        return nums[mid];
    }
};

3）其他解法

（1）
在这里插入图片描述我们首先将 lo 和 hi 指向数组首尾两个元素。然后进行二分搜索将数组搜索空间减半，直到找到单一元素或者仅剩一个元素为止。当搜索空间只剩一个元素，则该元素就是单个元素。
在每个循环迭代中，我们确定 mid，变量 halvesAreEven = (hi - mid) % 2 == 0。 通过查看中间元素同一元素为哪一个（左侧子数组中的最后一个元素或右侧子数组中的第一个元素），我们可以通过变量 halvesAreEven 确定现在哪一侧元素个数为奇数，并更新 lo 和 hi。
最难的部分是根据 mid 和 halvesAreEven 的值正确更新 lo 和 hi。我们通过下图来帮助我们理解

在这里插入图片描述

class Solution {
public:
    int singleNonDuplicate(vector<int>& nums) {
        int lo = 0;
        int hi = nums.size() - 1;
        while (lo < hi) {
            int mid = lo + (hi - lo) / 2;
            bool halvesAreEven = (hi - mid) % 2 == 0;
            if (nums[mid + 1] == nums[mid]) {
                if (halvesAreEven) {
                    lo = mid + 2;
                } else {
                    hi = mid - 1;
                }
            } else if (nums[mid - 1] == nums[mid]) {
                if (halvesAreEven) {
                    hi = mid - 2;
                } else {
                    lo = mid + 1;
                }
            } else {
                return nums[mid];
            }
        }
        return nums[lo];
    }
};

（2）仅对偶数索引进行二分搜索
事实证明我们只需要对偶数索引进行二分搜索。这种方法与方法二都是不错的方法，但是该方法比方法二更加优雅。
在该算法中，我们对所有偶数索引进行搜索，直到遇到第一个其后元素不相同的索引。
我们可以使用二分搜索替代线性搜索。
在单个元素的后面，则成对的元素变为奇数索引后跟他们的同一元素。说明我们在检索单个元素后面的偶数索引时，其后都没有它的同一元素。因此，我们可以通过偶数索引确定单个元素在左侧还是右侧。
算法：

奇数长度的数组首尾元素索引都为偶数，因此我们可以将 lo 和 hi 设置为数组首尾。
我们需要确保 mid 是偶数，如果为奇数，则将其减 1。
然后，我们检查 mid 的元素是否与其后面的索引相同。
如果相同，则我们知道 mid 不是单个元素。且单个元素在 mid 之后。则我们将 lo 设置为 mid + 2。
如果不是，则我们知道单个元素位于 mid，或者在 mid 之前。我们将 hi 设置为 mid。
一旦 lo == hi，则当前搜索空间为 1 个元素，那么该元素为单个元素，我们将返回它。


class Solution {
public:
    int singleNonDuplicate(vector<int>& nums) {
        int lo = 0;
        int hi = nums.size() - 1;
        while (lo < hi) {
            int mid = lo + (hi - lo) / 2;
            if (mid % 2 == 1) mid--;
            if (nums[mid] == nums[mid + 1]) {
                lo = mid + 2;
            } else {
                hi = mid;
            }
        }
        return nums[lo];
    }
};

作者：LeetCode
链接：link
来源：力扣（LeetCode）

4）自己的优化代码

c++

class Solution {
public:

     bool isfront(int mid,vector<int>& nums)
     {
         if(mid%2==0)
         {
             if(nums[mid]==nums[mid-1])return true;
             else return false;
         }
         else 
         {
             if(nums[mid]==nums[mid-1])return false;
             else return true;
         }
     }
    int singleNonDuplicate(vector<int>& nums) {
        int l=0,r=nums.size()-1,mid=-1;
        
        if(nums.size()==1)return nums[0];

        while(l<=r)
        {
            mid=(l+r)/2;
            if(mid==0&&nums[mid]!=nums[mid+1])break;
            else if(mid==nums.size()-1&&nums[mid]!=nums[mid-1])break;
            else if(nums[mid]!=nums[mid-1]&&nums[mid]!=nums[mid+1])break;
            else if(isfront(mid,nums))r=mid-1;
            else l=mid+1;
        }
        return nums[mid];
    }
};

5）学到的东西

二分查找法
仅对偶数进行二分搜索
判断两侧数字的个数为基数还是偶数

4、第一个错误的版本（278、Easy）

1）题目要求

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。

假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。

你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

示例:

给定 n = 5，并且 version = 4 是第一个错误的版本。

调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true

所以，4 是第一个错误的版本。

2）我的解法

c++
双百


class Solution {
public:
    int firstBadVersion(int n) {
       int l=1,r=n,mid=-1;
       while(l<=r)
       {
           mid=l+(r-l)/2;
           if(isBadVersion(mid))
           {
               if(!isBadVersion(mid-1))break;
               else r=mid-1;
           }
           else l=mid+1;
           
       } 
       return mid;
    }
};

3）其他解法

// The API isBadVersion is defined for you.
// bool isBadVersion(int version);

class Solution {
public:

	int firstBadVersion(int n) {

		int left = 1;
		int right = n;

		while (left < right) //相等时 即为第一个错误版本
		{
			int mid = left + (right - left) / 2;

			if (!isBadVersion(mid)) //正确版本
			{
				left = mid + 1;
			}
			else //错误版本
			{
				right = mid;
			}
		}

		return left;
	}
};

作者：eric-345
链接：link
来源：力扣（LeetCode）

4）自己的优化代码

c++

class Solution {
public:
    int firstBadVersion(int n) {
       int l=1,r=n,mid=-1;
       while(l<=r)
       {
           mid=l+(r-l)/2;
           if(isBadVersion(mid))
           {
               if(!isBadVersion(mid-1))break;
               else r=mid-1;
           }
           else l=mid+1;
           
       } 
       return mid;
    }
};

5）学到的东西

二分查找

5、旋转数组的最小数字（153、Medium）

1）题目要求

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

请找出其中最小的元素。

你可以假设数组中不存在重复元素。

示例 1:

输入: [3,4,5,1,2]
输出: 1
示例 2:

输入: [4,5,6,7,0,1,2]
输出: 0

2）我的解法

c++

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

3）其他解法

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

题解较长，点进链接仔细看

作者：armeria-program
链接：link
来源：力扣（LeetCode）

4）自己的优化代码

c++

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

5）学到的东西

可以让mid和left,right进行比较

列举可能性找规律

6、查找区间（34、Medium）

1）题目要求

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

你的算法时间复杂度必须是 O(log n) 级别。

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

示例 1:

输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]
示例 2:

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

2）我的解法

c++

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> result(2,-1);
        int l=0,r=nums.size()-1,mid=-1;
        while(l<=r)
        {
            mid=l+(r-l)/2;
            if(nums[mid]<target)l=mid+1;
            else if(nums[mid]>target)r=mid-1;
            else
            {
                l=mid;r=mid;
                while(l!=0&&nums[l-1]==target)
                {
                      l--;
                }
                result[0]=l;
                while(r!=nums.size()-1&&nums[r+1]==target)
                {
                     r++;
                }
                result[1]=r;
                break;
            }
        }
        return result;
    }
};

3）其他解法

利用二分思想先找其左边界，再找其右边界即可，注意找左边界的时候，由右侧逼近；找右边界的时候，由左侧逼近，即可。


class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> res(2,-1);
        if(nums.empty()) return res;
        int n=nums.size(),l=0,r=n-1;
        while(l<r){
            int m=l+(r-l)/2;
            if(nums[m]>=target) r=m;
            else l=m+1;
        }
        if(nums[l]!=target) return res;
        res[0]=l;
        r=n;
        while(l<r){
            int m=l+(r-l)/2;
            if(nums[m]<=target) l=m+1;
            else r=m;
        }
        res[1]=l-1;
        return res;
    }
};

作者：唐炜依
来源：力扣（LeetCode）评论区第一条

4）自己的优化代码

c++

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> result(2,-1);
        int l=0,r=nums.size()-1,mid=-1;
        if(nums.size()==0)return result;//特殊情况
        while(l<r)
        {
            mid=l+(r-l)/2;
            if(nums[mid]<target)l=mid+1;
            else r=mid;
        }
        if(nums[l]!=target)return result;//特殊情况
        result[0]=l;
        r=nums.size();//记得重新初始化,不-1相当于在数组后面加了一个元素，方便处理
        while(l<r)
        {
            mid=l+(r-l)/2;
            if(nums[mid]>target)r=mid;
            else l=mid+1;
        }
        result[1]=r-1;//记得-1
        return result;
    }
};

5）学到的东西

分别找左右边界，

学会二分查找的变种实现

public int binarySearch(int[] nums, int key) {
    int l = 0, h = nums.length - 1;
    while (l < h) {
        int m = l + (h - l) / 2;
        if (nums[m] >= key) {
            h = m;
        } else {
            l = m + 1;
        }
    }
    return l;
}

总结

正常实现

Input : [1,2,3,4,5]
key : 3
return the index : 2

public int binarySearch(int[] nums, int key) {
    int l = 0, h = nums.length - 1;
    while (l <= h) {
        int m = l + (h - l) / 2;
        if (nums[m] == key) {
            return m;
        } else if (nums[m] > key) {
            h = m - 1;
        } else {
            l = m + 1;
        }
    }
    return -1;
}

时间复杂度

二分查找也称为折半查找，每次都能将查找区间减半，这种折半特性的算法时间复杂度为 O(logN)。

m 计算

有两种计算中值 m 的方式：

m = (l + h) / 2
m = l + (h - l) / 2
l + h 可能出现加法溢出，也就是说加法的结果大于整型能够表示的范围。但是 l 和 h 都为正数，因此 h - l 不会出现加法溢出问题。所以，最好使用第二种计算法方法。

未成功查找的返回值

循环退出时如果仍然没有查找到 key，那么表示查找失败。可以有两种返回值：

-1：以一个错误码表示没有查找到 key
l：将 key 插入到 nums 中的正确位置
变种

二分查找可以有很多变种，实现变种要注意边界值的判断。例如在一个有重复元素的数组中查找 key 的最左位置的实现如下：

public int binarySearch(int[] nums, int key) {
    int l = 0, h = nums.length - 1;
    while (l < h) {
        int m = l + (h - l) / 2;
        if (nums[m] >= key) {
            h = m;
        } else {
            l = m + 1;
        }
    }
    return l;
}

该实现和正常实现有以下不同：

h 的赋值表达式为 h = m
循环条件为 l < h
最后返回 l 而不是 -1
在 nums[m] >= key 的情况下，可以推导出最左 key 位于 [l, m] 区间中，这是一个闭区间。h 的赋值表达式为 h = m，因为 m 位置也可能是解。

波仔头
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二分查找的一般形态及左右逼近变式(LeetCode:34)
AKGWSB 's blog
02-20 534
二分查找对于有序的数组是十分好用的查找方法，其使用分治法，将数组一分为二，每次排除一半的元素，复杂度是O(log(n)) 一般形态：数组中没有重复元素 【更为详细的版本】 将数组分为 左边一坨 中间元素 右边一坨 0~mid-1 mid mid+1~end 如果中间元素是目标，找到 如果中间元素小于目标，在右边一坨找 如果中间元素大于目标，在左边一坨找 vector<int>...
leetcode_python
02-10
在LeetCode上，题目通常涉及基础算法和数据结构，例如排序算法（如快速排序、归并排序）、搜索算法（如二分查找、深度优先搜索、广度优先搜索）、树结构（如二叉树、平衡二叉树）和图论等。Python的内置函数和标准库...
二分查找（入门）
jk1024的博客
07-28 292
二分查找法，又称折半查找法。它是一个很高的查找方法。时间复杂度是log(N)。我感觉就是枚举答案的方法，只是比暴力枚举快了很多但该方法是建立在有序的前提下的，基本思路就是先找到答案范围[l,r]的中间值mid，然后用根据题意写的check函数判断更新lorr。......
二分查找（基础）
qq_61637982的博客
02-01 1137
二分查找（入门级别）基础篇 一、二分查找的主体 二、 二分查找解析 1. 2. 总结 ...
算法刷题入门数据结构|二分查找
weixin_42575593的博客
12-11 2258
一.二分查找基础 1、二分查找介绍 二分查找(Binary search)也称折半查找，是一种效率较高的查找方法，时间复杂度。当对查数题目有时间复杂度要求是，首先就要考虑到二分查找。二分查找的思想很简单，属于分治策略的变种情况。但是，二分查找要求线性表中的记录必须是有序的集合，每次都通过跟区间的中间元素对比，将待查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间被缩小为 0，所以必须采用...
Leetcode_入门_回溯
波仔头的博客
10-01 216
Leetcode_入门_搜索BST1、1）题目要求2）我的解法3）其他解法4）自己的优化代码5）学到的东西 BST 1、 1）题目要求 2）我的解法 3）其他解法 4）自己的优化代码 5）学到的东西
Leetcode_入门_双指针
波仔头的博客
07-02 340
Leetcode _1双指针1、两数之和1）题目要求2）我的解法3）最优解法4）其他解法2、平方数之和1）题目要求2）我的解法3）最优解法4）其他解法3、反转字符串中的元音字符1）题目要求2）我的解法3）最优解法4）其他解法4、1）题目要求2）我的解法3）最优解法4）其他解法5、1）题目要求2）我的解法3）最优解法4）其他解法 1、两数之和 1）题目要求 给定一个已按照升序排列 的有序数组，找到两个数使得它们相加之和等于目标数。 函数应该返回这两个下标值 index1 和 index2，其中 index1
Leetcode_入门_图
波仔头的博客
10-05 185
Leetcode_入门_图二分图1、1）题目要求2）我的解法3）其他解法4）自己的优化代码5）学到的东西2、1）题目要求2）我的解法3）其他解法4）自己的优化代码5）学到的东西3、1）题目要求2）我的解法3）其他解法4）自己的优化代码5）学到的东西4、1）题目要求2）我的解法3）其他解法4）自己的优化代码5）学到的东西5、1）题目要求2）我的解法3）其他解法4）自己的优化代码5）学到的东西 二分图 1、 1）题目要求 2）我的解法 3）其他解法 4）自己的优化代码 5）学到的东西 2、 1）题目
leetcode跳跃-leetcode_java:锻炼
06-30
2. **查找**：包括线性查找、二分查找、哈希查找等，是数据搜索的关键技术。 3. **tree**：可能涉及到二叉树、平衡树（AVL、红黑树）或堆等数据结构，它们在数据存储和检索中扮演重要角色。 4. **字符串**：字符串...
hc_leetcode_prob：此存储库包含fizzbuzz和各种ds和algos问题的解决方案
02-15
包括排序（如快速排序、归并排序）、查找（如二分查找、哈希查找）、图遍历（如深度优先搜索、广度优先搜索）等。掌握算法是提高编程能力的关键。 4. **Python编程**：Python语法简洁，适合初学者入门。它的标准库...
入门算法leetcode面试题刷题
09-14
本篇文章将围绕“入门算法leetcode面试题刷题”这一主题展开讨论，重点解析其中提到的关键知识点，包括算法基础、常用及高级数据结构、递归与回溯、排序算法、深度与广度优先搜索、动态规划、二分搜索与贪婪算法以及...
LeetCode
02-13
2. **搜索算法**：二分查找、深度优先搜索（DFS）、广度优先搜索（BFS）等。这些算法在解决实际问题中非常常见，如在大量数据中查找特定元素或遍历树结构。 3. **数据结构**：数组、链表、栈、队列、哈希表、树、图...
力扣Hot100-994腐烂的橘子
最新发布
qq_52241267的博客
08-10 320
由于在找到腐烂水果后直接将它周围的水果置为腐烂水果，但是可能当前轮次腐烂的水果，又在当前轮次中影响周围水果，导致错误，所以可以标记：在不同轮次中被传染腐烂的水果标记为不同的数字，由于一开始time=0时，腐烂水果标记为2，所以在time=0到1这段时间被传染的水果标记为2+time+1,这样就可以使得本轮time=0时不会让标记为3的水果传染它周围的水果。左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个方向上。因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0。
leetcode 67. 二进制求和
LIHONGLI000125的博客
08-08 319
示例 1：输入:a = “11”, b = “1”输出：“100”示例 2：输入：a = “1010”, b = “1011”输出：“10101”提示：a 和 b 仅由字符 ‘0’ 或 ‘1’ 组成字符串如果不是 “0” ，就不含前导零。
三数之和-Leetcode
weixin_43993064的博客
08-07 353
这里去重要注意两个指针移动过程中也要去重！
力扣面试150 基本计算器 双栈模拟
人言束负
08-07 254
满注释版
leetcode-27-移除元素
jiao_mrswang的博客
08-07 239
1、统计数组nums中出现val的次数n；2、利用循环进行n次删除nums中的val;3、返回nums的长度。
力扣LeetCode精选题解与面试攻略
6. 面试必考的二分查找算法 - 对于面试中的核心算法技巧，如搜索和排序算法的深入解析。 7. 力扣专属面试资料 - 提供针对性的面试技巧和常见面试题库，强化面试准备。 8. 684. 冗余连接 - 验证图论知识，学习如何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值