LeetCode 刷题（一）算法基础

最新推荐文章于 2025-12-21 15:46:06 发布

原创最新推荐文章于 2025-12-21 15:46:06 发布 · 552 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #leetcode #数据结构

算法入门专栏收录该内容

13 篇文章

订阅专栏

这篇博客介绍了在排序数组中查找元素的第一个和最后一个位置、搜索旋转排序数组以及在二维矩阵中搜索的方法。通过二分查找和顺序遍历，结合数组特性解决这些经典问题，提供了解题思路和C++实现代码。

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

思路：在学习过数据结构与算法以后，几种常见的查找算法：顺序查找、二分查找、B树、分块查找、散列查找等等。通常情况下，我们选择则二分查找也就是折半查找就可以了，当然，如果题目给的数据结构非常切合某一特定算法也是可以考虑的。

二分查找的思想就是：基于原本的有序顺序，我们先与初始序列中间的元素比较，这样就可以当前元素的选择范围缩小一半。

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int n = nums.size();
        vector<int> res(2);
        res[0]= -1;
        res[1]= -1;
        int low = 0 , high = n-1;
        while(low<=high){
            int mid = low + (high -low )/2;
            if(nums[mid]<target)
                low = mid + 1 ;
            if(nums[mid]>target)
                high = mid -1;
            if(nums[mid]==target){
                res[0] = mid;
                break;
            }       
        }
        //没有查找到
        if(res[0]==-1)
            return res;
        //向前找到第一个位置    
        while(res[0]>0&&nums[res[0]-1]==target)
            res[0]--;
        res[1] = res[0];
        //向后去找最后一个位置
        while(res[1]<n-1&&nums[res[1]+1]==target)
            res[1]++;
        return res;
        
        
    }
};

33. 搜索旋转排序数组

思路：旋转后的数组nums本质上是两个有序的子序列。所以我们可以顺序遍历去找到两个子序列的分界点，然后分别对两个子序列进行二分查找。

class Solution {
public:
    int BinarySearch(int low,int high,int target,vector<int>& nums){
        while(low<=high){
            int mid = low + (high-low)/2;
            if(nums[mid]==target)
                return mid;
            if(nums[mid]>target)
                high = mid -1;
            if(nums[mid]<target)
                low = mid + 1;
        }
        return -1;
    }
    int search(vector<int>& nums, int target) {
        int n = nums.size();
        if(n==0)
            return -1;
        //不用判断旋转分界点
        if(n==1)
        {
            if(nums[0]==target)
                return 0;
            else
                return -1;
        }
        int k=n-1;
        //找到分界点
        while(k>0&&nums[k]>nums[k-1])
            k--;
        int ans;
        ans = BinarySearch(0,k-1,target,nums);
        if(ans!=-1)
            return ans;
        ans = BinarySearch(k,n-1,target,nums);
        if(ans!=-1)
            return ans;
        return -1;    
        
    }
};

74. 搜索二维矩阵

思路：二分查找确定在哪一行，再在这一行中二分查找确定位置。

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        int m = matrix.size();
        int n = matrix[0].size();
        //二分查找所在行  matrix[i][0]<=target<matrix[i+1][0]
        int low = 0 , high = m - 1;
        int mid1,mid2;
        //找到可能在的行
        while(low<=high){
            mid1 = low + (high - low ) / 2;
            if(matrix[mid1][0]>target)
                high = mid1 - 1;
            else if(matrix[mid1][n-1]<target)
                low = mid1 +1;
            else 
                break;
        }
        //没有行包含target
        if(low>high)
            return false;
        //在里面查找
        low =0 ; high =n-1; 
        while(low<=high){
            mid2 = low + (high - low) / 2;
            if(matrix[mid1][mid2]==target)
                return true;
            if(matrix[mid1][mid2]<target)
                low = mid2 +1;
            if(matrix[mid1][mid2]>target)
                high = mid2 -1;
        }
        return false;
    }
};