算法题总结----数组（二分查找）

最新推荐文章于 2024-04-20 15:12:32 发布
最新推荐文章于 2024-04-20 15:12:32 发布
阅读量554 收藏
点赞数
文章标签： 数据结构与算法 面试
原文链接：http://www.cnblogs.com/myblog1993/p/10914792.html
版权

数组相关----二分查找

查找插入位置

OJ链接

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

你可以假设数组中无重复元素。

示例 1:

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

示例 2:

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

示例 3:

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

示例 4:

输入: [1,3,5,6], 0
输出: 0

解答

二分查找，注意如果没找到应该返回l：

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

旋转数组的最小数字

OJ链接

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素

例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1

NOTE：给出的所有元素都大于0，若数组大小为0，请返回0

解答

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        if(rotateArray.size() == 0)
            return 0;
        if(rotateArray.size() == 1)
            return rotateArray[0];
        
        int sz = rotateArray.size();
        int l = 0,r = sz - 1;
        //如果没有旋转，不会进入循环，这样初始化会直接返回最左边元素
        int mid = l;
        while(rotateArray[r] <= rotateArray[l]){
            if(r - l == 1){
                mid = r;
                break;
            }
            mid = (l + r) >> 1;
            //如果首尾元素以及中间元素相等，那么没有办法判断中间元素到底是在左半部分还是右半部分，这时只能用顺序查找
            if(rotateArray[l] == rotateArray[r] && rotateArray[l] == rotateArray[mid]){
                int min = rotateArray[0];
                for(int i = 1;i < sz;i++){
                    if(rotateArray[i] < min) 
                        min = rotateArray[i];
                }
                return min;
            }
            if(rotateArray[mid] >= rotateArray[l])
                l = mid;
            else if(rotateArray[mid] <= rotateArray[r])
                r = mid;
        }
        return rotateArray[mid];
    }
};

旋转数组中查找数字

OJ链接

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

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

搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

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

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

示例 1:

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

示例 2:

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

解答

  • 首先，如果nums[mid] == target，那么找到目标元素，返回mid
  • 如果nums[l] < nums[r]，说明l~r范围的元素有序，那么执行正常的二分查找
  • 否则，根据mid位置的值判断mid是在左半部分还是右半部分
    • 如果nums[mid] ≥ nums[l]，说明mid在左半部分
      • 当target > nums[r] && target < nums[mid]，那么target只可能出现在mid的左边，因此在mid左边继续查找
      • 否则，target只可能出现在mid的右边，因此在mid右边继续查找
    • 否则，mid在右半部分
      • 当target > nums[mid] && target < nums[l]，那么target只可能出现在mid的右边，因此在mid右边继续查找
      • 否则，target只可能出现在mid的左边，因此在mid左边继续查找
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int l = 0,r = nums.size() - 1;
        while(l <= r){
            int mid = (l + r) / 2;
            if(nums[mid] == target) return mid;
            if(nums[l] < nums[r]){
                if(nums[mid] < target)   l = mid + 1;
                else                     r = mid - 1;
            }
            else{
                if(nums[mid] >= nums[l]){//mid在左边
                    if(target > nums[r] && target < nums[mid])  r = mid - 1;
                    else    l = mid + 1;
                }
                else{//mid在右边
                    if(target > nums[mid] && target < nums[l])  l = mid + 1;
                    else    r = mid - 1;
                }
            }
        }
        return -1;
    }
};

旋转数组中查找数字II

OJ链接

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

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

编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。

示例 1:

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

示例 2:

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

进阶:

  • 这是 旋转数组中查找数字 的延伸题目，本题中的 nums 可能包含重复元素
  • 这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？

解答

相比于前一题，这一题可能包含重复

总的思路还是不变，不过要处理一种特殊情况，即nums[l] == nums[r] && nums[l] == nums[mid]时，此时无法确定mid在左半部分还是右半部分。因此，当出现这种情况时，在区间[l,r]中，执行顺序查找

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        int l = 0,r = nums.size() - 1;
        while(l <= r){
            int mid = (l + r) / 2;
            if(nums[mid] == target) return true;
            if(nums[l] < nums[r]){
                if(nums[mid] < target)   l = mid + 1;
                else                     r = mid - 1;
            }
            else{
                if(nums[l] == nums[r] && nums[l] == nums[mid]){//无法知道mid在左边还是右边
                    for(int i = l;i <= r;i++)
                        if(nums[i] == target)
                            return true;
                    return false;
                }
                else{ //能确定mid的位置
                    if(nums[mid] >= nums[l]){//mid在左边
                        if(target > nums[r] && target < nums[mid])  r = mid - 1;
                        else    l = mid + 1;
                    }
                    else{//mid在右边
                        if(target > nums[mid] && target < nums[l])  l = mid + 1;
                        else    r = mid - 1;
                    }
                }
            }
        }
        return false;
    }
};

有序数组中查找数字的范围

OJ链接

统计一个数字在排序数组中出现的次数

解答

使用二分查找，分别找到数字的下边界和上边界

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

缺失的数字

一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0~n-1之内。在范围0~n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字

解答

数组中开始的一些数字与它们的下标相同，如果m不在数组中，则下标m位置的元素是m+1...问题转换为找到数组中下标和元素值不相等的第一个元素

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

数组中数值和下标相等的元素

假设一个单调递增的数组里的每个元素都是整数并且是唯一的。请编程实现一个函数找出数组中任意一个数值等于其下标的元素。例如，在数组{-3, -1, 1, 3, 5}中，数字3和它的下标相等

解答

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

查找数组中任一峰值的下标

OJ链接

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

给定一个输入数组 nums，其中 nums[i] ≠ nums[i+1]，找到峰值元素并返回其索引。

数组可能包含多个峰值，在这种情况下，返回任何一个峰值所在位置即可。

你可以假设 nums[-1] = nums[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。

说明:

你的解法应该是 O(logN) 时间复杂度的

解答

1）线性查找

遍历数组，对于每个元素，如果该元素的前一元素和后一元素都小于该元素，那么该元素是一个峰值，返回

  • 时间复杂度：O(n)
  • 空间复杂度：O(1)
2）二分查找
  • 如果中间元素比右边的元素小，意味着当前处于一个“升序”中，那么右边(不含当前元素)将会出现一个峰值
  • 如果中间元素比右边的元素大，意味着当前处于一个“降序”中，那么左边(包含当前元素)将会出现一个峰值
  • 如果中间元素等于右边的元素，那么无法减小区间（所以题目给出了nums[i]不等于nums[i+1]）

使用上述判断一直减小区间，直到区间只有1个元素

  • 时间复杂度：O(logn)
  • 空间复杂度：O(1)
class Solution {
public:
    int findPeakElement(vector<int>& nums) {
        int ret = -1;
        int l = 0,r = nums.size() - 1,mid;
        while(l < r){
            mid = (l + r) >> 1;
            if(nums[mid] < nums[mid + 1])
                l = mid + 1;
            else if(nums[mid] > nums[mid + 1])
                r = mid;
            //假设输入合法，如果nums[mid] == nums[mid+1]会无限循环
            //为了代码的简洁性暂时不处理这种情况
        }
        return l == r ? l : -1;
    }
};

两个排序数组的中值

OJ链接

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2 。

请找出这两个有序数组的中位数。要求算法的时间复杂度为 O(log (m+n))

示例 1:

nums1 = [1, 3]
nums2 = [2]

中位数是 2.0

示例 2:

nums1 = [1, 2]
nums2 = [3, 4]

中位数是 (2 + 3)/2 = 2.5

解答

1）归并

使用一个辅助数组，使用归并排序的合并方法将两个数组合并，排成一个按序排序的数组，然后求中值：

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int idx1 = 0,idx2 = 0,idx = 0,sz1 = nums1.size(),sz2 = nums2.size();
        vector<int> nums(sz1 + sz2,0);
        while(idx1 != sz1 && idx2 != sz2){
            if(nums1[idx1] < nums2[idx2])   nums[idx++] = nums1[idx1++];
            else nums[idx++] = nums2[idx2++];
        }
        while(idx1 != sz1)  nums[idx++] = nums1[idx1++];
        while(idx2 != sz2)  nums[idx++] = nums2[idx2++];
        
        if((sz1 + sz2) % 2 == 0)
            return (double)(nums[(sz1 + sz2 - 1) / 2] + nums[(sz1 + sz2) / 2]) / 2;
        else
            return nums[(sz1 + sz2) / 2];
    }
};
  • 时间复杂度：O(m + n)
  • 空间复杂度：O(m + n)

时间复杂度不满足题目要求，但是这种方法也能accept

2）归并（不使用辅助空间）

还是使用归并排序合并的思想，但是不使用辅助数组，根据两个数组的大小判断中值的下标，然后归并过程中递增下标，直到到达中值的下标。这样可以避免使用额外空间

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int idx1 = 0,idx2 = 0,sz1 = nums1.size(),sz2 = nums2.size();
        int end1 = (sz1 + sz2 - 1) / 2, end2 = (sz1 + sz2) % 2 ? -1 : (sz1 + sz2) / 2,begin = 0;
        int num1,num2;
        
        while(idx1 != sz1 && idx2 != sz2){
            if(begin == end1){
                num1 = nums1[idx1] < nums2[idx2] ? nums1[idx1] : nums2[idx2];
                if(end2 == -1)   return num1;
            }
            if(begin == end2){
                num2 = nums1[idx1] < nums2[idx2] ? nums1[idx1] : nums2[idx2];
                return (double)(num1 + num2) / 2;
            }
            if(nums1[idx1] < nums2[idx2])   idx1++;
            else    idx2++;
            begin++;
        }
        
        while(idx1 != sz1){
            if(begin == end1){
                num1 = nums1[idx1];
                if(end2 == -1)   return num1;
            }
            if(begin == end2){
                num2 = nums1[idx1];
                return (double)(num1 + num2) / 2;
            }
            idx1++;
            begin++;
        }
        while(idx2 != sz2){
            if(begin == end1){
                num1 = nums2[idx2];
                if(end2 == -1)   return num1;
            }
            if(begin == end2){
                num2 = nums2[idx2];
                return (double)(num1 + num2) / 2;
            }
            idx2++;
            begin++;
        }
        
        return 0;//nums1和nums2都为空
    }
};
  • 时间复杂度：O(m + n)
  • 空间复杂度：O(1)

时间复杂度不满足题目要求，但是这种方法也能accept

3）二分法

要求O(log(m+n))的时间复杂度，那么必须使用二分法，那么如何进行二分？考虑将数组num1分为2部分[part1,part3]，将数组num2分为2部分[part2,part4]，然后假设part1包含sz1个元素，part2包含sz2个元素。那么我们肯定是要找到part1和part2，使得：

sz1+sz2 = len/2，len为两个数组总长

可以以len/2为长度总和，以part1为基准：

  • 当part1变大时，sz1扩大，那么sz2必须减小，因此part2要减小
  • 当part1变小时，sz1减小，那么sz2必须扩大，因此part2要扩大

现在问题是根据什么标准来扩大或减小part1？这里设4个变量：

  1. part1中最右边的元素（即part1最大的元素）为l1
  2. part3中最左边的元素（即part3最小的元素）为r1
  3. part2中最右边的元素（即part2最大的元素）为l2
  4. part4中最左边的元素（即part4最小的元素）为r2

由于part1和part2必须为数组nums1和nums2组成数组的前半部分，那么必须满足：

l1 <= r1（已经满足）
l1 <= r2
l2 <= r1
l2 <= r2（已经满足）

因此，可以根据中间两个条件是否满足来扩大或减小part1

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        if(nums2.size() < nums1.size())
            return findMedianSortedArrays(nums2,nums1);
        
        int sz = nums1.size() + nums2.size();
        int sz1l = 0,sz1r = nums1.size();
        int sz1 = 0,sz2 = 0;
        while(sz1 <= nums1.size()){
            sz1 = (sz1l + sz1r) / 2;
            sz2 = sz / 2 - sz1; 
            int l1 = sz1 == 0 ? INT_MIN : nums1[sz1 - 1];
            int r1 = sz1 == nums1.size() ? INT_MAX : nums1[sz1];
            int l2 = sz2 == 0 ? INT_MIN : nums2[sz2 - 1];
            int r2 = sz2 == nums2.size() ? INT_MAX : nums2[sz2];
            if(l1 > r2)
                sz1r = sz1 - 1;
            else if(l2  > r1)
                sz1l = sz1 + 1;
            else{
                if(sz % 2 == 0){
                    l1 = l1 > l2 ? l1 : l2;
                    r1 = r1 < r2 ? r1 : r2;
                    return (double)(l1 + r1) / 2;
                }
                else{
                    r1 = r1 < r2 ? r1 : r2;
                    return r1;
                }
            }
                
        }
        
        return -1;
    }
};
  • 时间复杂度：O(log(min(m,n)))
  • 空间复杂度：O(1)

转载于:https://www.cnblogs.com/myblog1993/p/10914792.html

weixin_34067102
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数组中数值和下标相等的元素（二分查找）
fanc的博客
12-11 1102
题目描述 假设一个单调递增的数组中的每个元素都是整数并且是唯一的。请编程实现一个函数，找出数组中任意一个数值等于其下标的元素，例如在数组【-3，-1，1，3，5】中，3和他的下标相等。 采用二分查找：如果数组中的数字小于下标，由于下标是-1的递减数列，但是数组中的元素差值大于等于-1，因此左边的不可能等于下标。如果数组中的数字大于下标，同理，之后的数字肯定都大于下标，往左边查找。 class So...
算法题总结（二）
SiranTang的博客
04-22 185
C++ 数据结构与算法 后台开发 面试
day13：69. 数组中数值和下标相等的元素（二分法）
yangyangcome的博客
06-24 208
问题描述： 假设一个单调递增的数组里的每个元素都是整数并且是唯一的。请编程实现一个函数找出数组中任意一个数值等于其下标的元素。 例如，在数组[-3, -1, 1, 3, 5]中，数字3和它的下标相等。注意:如果不存在，则返回-1。 样例 输入：[-3, -1, 1, 3, 5] 输出：3 使用二分法，二分法使用前提必须是有序数列，在本题中，nums[i]-i>nums[i-1]-(i-1) 移项之后可以看出是递增序列。 计算中间位置mid=(l+r)/2 然后比较nums[mid]-mid 与
二分查找知识点及练习题
luhaimin7的博客
04-20 1155
二分查找知识点
二分2.找出数组中数值和下标相等的元素
weixin_47040809的博客
12-16 345
输入为递增数组，每个元素都是整数且唯一，值都在n-1之间 首先因为值在n-1之间想到循环排序，但这个以及是排序好了，所以用二分是O（logn）。 因为这是个递增数组而且每个元素都是整数且唯一，找出一个元素的下标和内容相同。二分查找，如果发现相等则返回，如果发现不相同，则如果下标大于值则往右找，下标小于值则往左找。 ...
day2（2）使用二分法查找元素下标、找出数组排序后的目标下标
m0_65522173的博客
03-02 367
使用二分法查找元素下标，找出数组排序后的目标下标
【剑指offer系列】56. 数组中数值和下标相等的元素
姚先生的全栈之路
07-28 119
【剑指offer系列】56. 数组中数值和下标相等的元素
算法题-1 二维数组查找
chenguihua5的博客
05-19 240
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 第一种正常遍历查找 public static void main(String[] args) { int[][] arr = {{1, 2, 8, 9}, {2, 4, 9, 12}, {4, 7, 10, 13}, {6, 8, 11, 15}}; System.o
c语言-顺序查找、二分查找代码.docx
12-16
二分查找是一种高效的查找算法，它的思路是从数组的中间元素开始，如果中间元素正好是要查找的元素，那么查找结束；如果大于或者小于中间元素，那么在数组大于或小于中间元素的那一半中查找。二分查找的技术点包括...
查找算法-二分查找详解
12-20
二分查找，也被称为折半查找，是一种在有序数组中高效地查找特定元素的搜索算法。这个算法充分利用了数组的线性存储结构，通过不断缩小查找范围，将查找时间复杂度降低到对数级别，极大地提高了查找效率。下面将详细...
java-二分查找.rar
最新发布
06-01
二分查找，也称为折半查找，是一种在有序数组中搜索特定元素的高效算法。它利用了数组的线性特性，每次将待搜索区域减半，直到找到目标元素或者确定不存在为止。在Java中实现二分查找，我们需要理解其基本原理和步骤...
冒泡和二分法的全部过程.txt
10-18
通过给定一组无序的数组，用冒泡排序将数组有序，并且通过二分法查找，找到其中的一个，并且返回下标，如果找不到则输出，找不到这几个字。
C#-使用C#实现的二分查找算法-算法实现.zip
02-25
二分查找算法是一种在有序数组中查找特定元素的搜索算法，具有高效的时间复杂度，是计算机科学中的基础算法之一。本资源"**C#-使用C#实现的二分查找算法-算法实现.zip**"提供了使用C#语言实现二分查找算法的详细代码...
二分查找算法实现-修正1
08-04
二分查找算法是计算机科学中一种常用的查找算法，通过将要查找的数组分成两半，并不断缩小查找范围来找到目标元素。该算法的实现可以在多种编程语言中使用，包括C++、Java、C#等。 在给定的文件中，我们可以看到一...
C++ 二分查找
m0_68710788的博客
11-14 1027
因为二分查找每一次查找都可以缩减掉一半的查找范围，由此可以知道二分查找法的时间复杂度是: log_2(N)。二分查找法，又称折半查找法。但该方法是建立在有序的前提下的，基本思路就是：我们可以先找到那个有序序列的中间元素a[mid]，然后拿它和要找的元素K进行比较，就可以判断K所在左半区还是右半区。当我们要从一个序列中查找一个元素的时候，最快想到的方法就是顺序查找法（即：从前到后依次查找）。请在一个有序递增数组中（不存在相同元素），采用二分查找，找出值x的位置，如果x在数组中不存在，请输出-1！
二分法的两种常用模板
Aaron_Yang
02-13 326
单调递增序列中找x或者x的后继 「在单调递增序列中找x 或者x的后继」，即在单调递增数列a[]中查找某个数x,如果数列中没有x,则找比它大的下一个数。前面所给出的bin_ search() 函数就是「在单调递增序列中找x或者x的后继」的模板代码。二分法有很多编码方法,这里给出的区间是左闭右开的编码，即[0, n)。也可以直接对[0,n- 1]区间二分,代码略有不同。 模板代码： int bin_search(int *a, int n, int x){ //a[0]～a[n-1]是单调递增的
数据结构与算法 | 二分查找
凌桓丶的博客
09-25 398
假如我们在图书馆中整理书记，书按照序号有序排序，序号不连续，当我们需要从书堆中找到特定序号的书时，如果一本一本查找的话，我们可能需要查找N次。但如果我们先找到中间的书，将书分成两堆，与待查书对比，待查书序号较大的时候从序号大的一堆中在分成两堆继续对比，书号小时从小的那堆继续对比，直到找到对应书号，这样只需查找log2(n)次。 这就是二分查找法。 例如我们有一个被排序好的数组 int a[10] ...
LeetCode 题解 数组 2.1.4 在旋转排序数组中搜索Ⅱ
Buzhibailu的博客
05-12 94
LeetCode 题解 2.1 数组 2.1.4 Search in Rotated Sorted ArrayⅡ 2.1.4 在旋转排序数组中搜索 题目描述 后续“在旋转排序数组中搜索”:如果允许重复怎么办? 这会影响运行时复杂度吗?如何以及为什么? 写一个函数来确定给定的目标是否在数组中。 代码思路： 要是允许有重复的元素，则可能会出现 [1，2，3，1，1，1] 这样的情况，这时候之前的判断条件，拿中间数和两边相比较，就有可能出现相等的情况，无法判断这一区间是否递增，这时就要特殊情况特殊判断，改变判断条
【数据结构与算法】二分查找算法
joy.728的博客
08-07 816
🎇🎇🎇每个优秀的人都有一段沉默的时光，那段时光是付出了很多努力却得不到结果的日子，我们把它叫做扎根🎇🎇🎇
全国计算机等级考试-二级ACCESS程序的设计和公共基础知识笔试知识点总结(可用)(word文档物超所值).pdf
11-13
全国计算机等级考试-二级ACCESS程序的设计和公共基础知识笔试知识点总结(可用)(word文档物超所值).pdf

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值