二分搜索之总结

最新推荐文章于 2022-05-28 22:02:06 发布
最新推荐文章于 2022-05-28 22:02:06 发布
阅读量237 收藏
点赞数
分类专栏： 算法与数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36725931/article/details/87927271
版权

文章目录

一、二分搜索的简介

二分搜索用于在一个有序数组中查找一个符合某些条件的值，如果找得到，则返回该值的下标或迭代器。

二分搜索的核心是不断根据中位数跟特定值比较的结果调整搜索区间，每次调整后的区间总是调整前区间长度的一半。

下文以升序数组为例进行阐述，降序数组同理。

二、二分搜索的基本问题

在升序数组 A 中，查找一个满足特定条件的数组成员 x，若查找成功则返回 x 的下标或迭代器，查找失败则返回 -1 或迭代器末端。一般有 3 种特定条件，描述如下。

  1. 数组 A 中的每个数只出现一次，x 等于特定数字 target。
  2. 数组 A 中的每个数出现不止一次，x 是第一个等于特定数字 target 的数。
  3. 数组 A 中的每个数出现不止一次，x 是第一个大于等于特定数字 target 的数。
  4. 数组 A 中的每个数出现不止一次，x 是第一个大于特定数字 target 的数。

第 2、3、4 三个问题有两个关键点，一是当中位数等于特定数字 target 时，区间要如何调整，是向右缩小还是向左缩小，二是在搜索的最后一步需要再次将中位数和特定数字 target 进行比较以确定最终返回值。在下文的具体程序演示中会以注释标记这两个关键点。

三、二分搜索的程序模板

(一) 迭代版

int
BinarySearchIteratively(const vector<int>& array, int left_index, int right_index,
                        int target) {
    while (left_index < right_index) {
        int mid_index = left_index + (right_index - left_index) / 2;
        if (array[mid_index] < target) {
            left_index = mid_index + 1;
        } else if (target < array[mid_index]) {
            right_index = mid_index;
        } else {
            /* 返回 mid_index 或进一步缩小搜索范围，视情况而定 */
        }
    }
    /* 返回 -1 或返回 left_index，视情况而定 */
}

(二) 递归版

int
BinarySearchRecursively(const vector<int>& array, int left_index, int right_index,
                        int target) {
    if (left_index == right_index) {
        /* 返回 -1 或返回 left_index，视情况而定 */
    }
    int mid_index = left_index + (right_index - left_index) / 2;
    if (array[mid_index] < target) {
        return BinarySearchRecursively(array, mid_index + 1, right_index, target);
    } else if (target < array[mid_index]) {
        return BinarySearchRecursively(array, left_index, mid_index, target);
    } else {
        /* 返回 mid_index 或进一步缩小搜索范围，视情况而定 */
    }
}

四、二分搜索的细节

(一) 求两整数平均值

二分搜索的每一轮比较之前总需要求出当前区间的中位数。中位数的下标就是区间两个数字的平均数向下取整。用最普通的两整数相加再除以 2 的方法存在溢出的可能，以下四种写法能减少溢出的风险。

int mid_1 = left + (right - left) / 2;
int mid_2 = (left >> 1) + (right >> 1) + (((left & 1) + (right & 1)) >> 1);
int mid_3 = (left & right) + ((left ^ right) >> 1);
int mid_4 = left + ((right - left) >> 1);

>>1 等同于 /2，但要注意加号的运算优先级高于移位符号，需要加上括号保证运算顺序合理。

(二) “左闭右开”的区间表示

笔者在程序模板中采用的区间表示法就是“左闭右开”，即[left_index, right_index)。在 C++ 的标准库中，凡是表示区间的两个形参都遵循“左闭右开”原则，示例如下。

int array[10] = {10, 1, 23, 14, 35, 26, 47 ,18 ,79};
sort(array, array + 10);

在 sort 函数的形参列表中，array 表示 10 的地址，array + 10 表示 79 的下一个地址。因此，为了和 C++ 标准库的区间表示法统一，建议读者也采用“左闭右开”原则。

若迭代或递归的原始区间为 [a, b)，则在最后一轮循环或最后一层递归搜索区间为 [b, b)。因此，二分搜索进行到最后会有 left_index 等于 right_index。

(三) 最后一步防止溢出

因为二分搜索进行到最后会有 left_index 等于 right_index，因此 left_index 可能等于数组长度即 array.size()，故如果此时需要访问 array[left_index]，需要添加 left_index 的范围判断。

五、二分搜索的详尽程序

(一) 升序无重复数，查找等于 target 的 A[i]

以下程序已通过 LeetCode 704. Binary Search 所有样例测试。

class Solution {
private:
    // 迭代版，搜索区间为 [left_index, right_index)
    int SearchIteratively(const vector<int> nums, int left_index, int right_index,
                          int target) {
        while (left_index < right_index) {
            int mid_index = left_index + (right_index - left_index) / 2;
            if (target < nums[mid_index]) {
                right_index = mid_index;
            } else if (nums[mid_index] < target) {
                left_index = mid_index + 1;
            } else {
                return mid_index;
            }
        }
        return -1;
    }
    // 递归版，搜索区间为 [left_index, right_index)
    int SearchRecursively(const vector<int>& nums, int left_index, int right_index,
                          int target) {
        if (left_index == right_index) {
            return -1;
        }
        int mid_index = left_index + (right_index - left_index) / 2;
        if (nums[mid_index] < target) {
            return SearchRecursively(nums, mid_index + 1, right_index, target);
        } else if (target < nums[mid_index]) {
            return SearchRecursively(nums, left_index, mid_index, target);
        } else {
            return mid_index;
        }
    }

public:
    int search(vector<int>& nums, int target) {
        // return SearchIteratively(nums, 0, nums.size(), target);
        return SearchRecursively(nums, 0, nums.size(), target);
    }
};

(二) 升序有重复数，查找第一个等于 target 的 A[i]

以下程序可直接复制粘贴后编译运行。

#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;

/**
 * 升序有重复数，查找第一个等于 target 的 A[i]，迭代版
 */
int
SearchFirstEqualIteratively(const vector<int>& array, int left_index, int right_index,
                            int target) {
    while (left_index < right_index) {
        int mid_index = left_index + (right_index - left_index) / 2;
        if (target < array[mid_index]) {
            right_index = mid_index;
        } else if (array[mid_index] < target) {
            left_index = mid_index + 1;
        } else { // 关键点一
            right_index = mid_index;
        }
    }
    // 关键点二
    if (left_index < array.size() && array[left_index] == target) {
        return left_index;
    } else {
        return -1;
    }
}

/**
 * 升序有重复数，查找第一个等于 target 的 A[i]，递归版
 */
int
SearchFirstEqualRecursively(const vector<int>& array, int left_index, int right_index,
                            int target) {
    if (left_index == right_index) {
        // 关键点二
        if (left_index < array.size() && array[left_index] == target) {
            return left_index;
        } else {
            return -1;
        }
    }
    int mid_index = left_index + (right_index - left_index) / 2;
    if (array[mid_index] < target) {
        return SearchFirstEqualRecursively(array, mid_index + 1, right_index, target);
    } else if (target < array[mid_index]) {
        return SearchFirstEqualRecursively(array, left_index, mid_index, target);
    } else { // 关键点一
        return SearchFirstEqualRecursively(array, left_index, mid_index, target);
    }
}

int
main(void) {
    vector<int> arr = { 1, 2, 2, 3, 6, 6, 6, 8, 12, 14 };
    int index = 0;
    int target = 0;

    cout << "array:";
    for (auto i : arr) {
        cout << ' ' << i;
    }
    cout << endl;

    cout << "---------------\nTest Iteration:" << endl;

    index = SearchFirstEqualIteratively(arr, 0, arr.size(), target = 10);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstEqualIteratively(arr, 0, arr.size(), target = 1);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstEqualIteratively(arr, 0, arr.size(), target = 2);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstEqualIteratively(arr, 0, arr.size(), target = 6);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstEqualIteratively(arr, 0, arr.size(), target = 14);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstEqualIteratively(arr, 0, arr.size(), target = 100);
    cout << "target = " << target << ": index = " << index << endl;

    cout << "---------------\nTest Recursion:" << endl;

    index = SearchFirstEqualRecursively(arr, 0, arr.size(), target = 10);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstEqualRecursively(arr, 0, arr.size(), target = 1);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstEqualRecursively(arr, 0, arr.size(), target = 2);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstEqualRecursively(arr, 0, arr.size(), target = 6);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstEqualRecursively(arr, 0, arr.size(), target = 14);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstEqualRecursively(arr, 0, arr.size(), target = 100);
    cout << "target = " << target << ": index = " << index << endl;

    return 0;
}

(三) 升序有重复数，查找第一个大于等于 target 的 A[i]

以下程序可直接复制粘贴后编译运行。

#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;

/**
 * 升序有重复数，查找第一个大于等于 target 的 A[i]，迭代版
 */
int
SearchFirstGreaterOrEqualIteratively(const vector<int>& array, int left_index, int right_index,
                            int target) {
    while (left_index < right_index) {
        int mid_index = left_index + (right_index - left_index) / 2;
        if (target < array[mid_index]) {
            right_index = mid_index;
        } else if (array[mid_index] < target) {
            left_index = mid_index + 1;
        } else { // 关键点一
            right_index = mid_index;
        }
    }
    // 关键点二
    if (left_index < array.size() && array[left_index] >= target) {
        return left_index;
    } else {
        return -1;
    }
}

/**
 * 升序有重复数，查找第一个大于等于 target 的 A[i]，递归版
 */
int
SearchFirstGreaterOrEqualRecursively(const vector<int>& array, int left_index, int right_index,
                            int target) {
    if (left_index == right_index) {
        // 关键点二
        if (left_index < array.size() && array[left_index] >= target) {
            return left_index;
        } else {
            return -1;
        }
    }
    int mid_index = left_index + (right_index - left_index) / 2;
    if (array[mid_index] < target) {
        return SearchFirstGreaterOrEqualRecursively(array, mid_index + 1, right_index, target);
    } else if (target < array[mid_index]) {
        return SearchFirstGreaterOrEqualRecursively(array, left_index, mid_index, target);
    } else { // 关键点一
        return SearchFirstGreaterOrEqualRecursively(array, left_index, mid_index, target);
    }
}

int
main(void) {
    vector<int> arr = { 1, 2, 2, 3, 6, 6, 6, 8, 12, 14 };
    int index = 0;
    int target = 0;

    cout << "array:";
    for (auto i : arr) {
        cout << ' ' << i;
    }
    cout << endl;

    cout << "---------------\nTest Iteration:" << endl;

    index = SearchFirstGreaterOrEqualIteratively(arr, 0, arr.size(), target = 10);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstGreaterOrEqualIteratively(arr, 0, arr.size(), target = 1);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstGreaterOrEqualIteratively(arr, 0, arr.size(), target = 2);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstGreaterOrEqualIteratively(arr, 0, arr.size(), target = 6);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstGreaterOrEqualIteratively(arr, 0, arr.size(), target = 14);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstGreaterOrEqualIteratively(arr, 0, arr.size(), target = 100);
    cout << "target = " << target << ": index = " << index << endl;

    cout << "---------------\nTest Recursion:" << endl;

    index = SearchFirstGreaterOrEqualRecursively(arr, 0, arr.size(), target = 10);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstGreaterOrEqualRecursively(arr, 0, arr.size(), target = 1);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstGreaterOrEqualRecursively(arr, 0, arr.size(), target = 2);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstGreaterOrEqualRecursively(arr, 0, arr.size(), target = 6);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstGreaterOrEqualRecursively(arr, 0, arr.size(), target = 14);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstGreaterOrEqualRecursively(arr, 0, arr.size(), target = 100);
    cout << "target = " << target << ": index = " << index << endl;

    return 0;
}

(四) 升序有重复数，查找第一个大于 target 的 A[i]

以下程序可直接复制粘贴后编译运行。

#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;

/**
 * 升序有重复数，查找第一个大于 target 的 A[i]，迭代版
 */
int
SearchFirstGreaterIteratively(const vector<int>& array, int left_index, int right_index,
                              int target) {
    while (left_index < right_index) {
        int mid_index = left_index + (right_index - left_index) / 2;
        if (target < array[mid_index]) {
            right_index = mid_index;
        } else if (array[mid_index] < target) {
            left_index = mid_index + 1;
        } else { // 关键点一
            left_index = mid_index + 1;
        }
    }
    // 关键点二
    if (left_index < array.size() && array[left_index] > target) {
        return left_index;
    } else {
        return -1;
    }
}

/**
 * 升序有重复数，查找第一个大于 target 的 A[i]，递归版
 */
int
SearchFirstGreaterRecursively(const vector<int>& array, int left_index, int right_index,
                              int target) {
    if (left_index == right_index) {
        // 关键点二
        if (left_index < array.size() && array[left_index] > target) {
            return left_index;
        } else {
            return -1;
        }
    }
    int mid_index = left_index + (right_index - left_index) / 2;
    if (array[mid_index] < target) {
        return SearchFirstGreaterRecursively(array, mid_index + 1, right_index, target);
    } else if (target < array[mid_index]) {
        return SearchFirstGreaterRecursively(array, left_index, mid_index, target);
    } else { // 关键点一
        return SearchFirstGreaterRecursively(array, mid_index + 1, right_index, target);
    }
}

int
main(void) {
    vector<int> arr = { 1, 2, 2, 3, 6, 6, 6, 8, 12, 14 };
    int index = 0;
    int target = 0;

    cout << "array:";
    for (auto i : arr) {
        cout << ' ' << i;
    }
    cout << endl;

    cout << "---------------\nTest Iteration:" << endl;

    index = SearchFirstGreaterIteratively(arr, 0, arr.size(), target = 10);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstGreaterIteratively(arr, 0, arr.size(), target = 1);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstGreaterIteratively(arr, 0, arr.size(), target = 2);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstGreaterIteratively(arr, 0, arr.size(), target = 6);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstGreaterIteratively(arr, 0, arr.size(), target = 14);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstGreaterIteratively(arr, 0, arr.size(), target = 100);
    cout << "target = " << target << ": index = " << index << endl;

    cout << "---------------\nTest Recursion:" << endl;

    index = SearchFirstGreaterRecursively(arr, 0, arr.size(), target = 10);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstGreaterRecursively(arr, 0, arr.size(), target = 1);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstGreaterRecursively(arr, 0, arr.size(), target = 2);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstGreaterRecursively(arr, 0, arr.size(), target = 6);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstGreaterRecursively(arr, 0, arr.size(), target = 14);
    cout << "target = " << target << ": index = " << index << endl;

    index = SearchFirstGreaterRecursively(arr, 0, arr.size(), target = 100);
    cout << "target = " << target << ": index = " << index << endl;

    return 0;
}

六、参考资料

二分查找有几种写法？它们的区别是什么？ - Jason Li的回答 - 知乎

庭树
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法设计实验二分搜索法
07-01
二分搜索法，又称折半查找，是一种在有序数组中查找特定元素的高效搜索算法。它的基本思想是将数组分成两半，每次比较中间元素与目标值，根据比较结果缩小搜索范围，直到找到目标元素或者搜索范围为空。这种方法充分...
二分查找心得
qq526843730的博客
03-24 565
二分查找
二分查找的一些总结
qq_42251399的博客
05-28 862
二分查找 在一个范围内，查找一个数字，要求找到这个元素的开始位置和结束位置，这个范围内的数字都是单调递增的，即具有单调性质，因此可以使用二分来做。二分查找的前提是数组中的数据必须有序。 注意，数组中的元素可能是严格单调递增，即数组中不存在重复元素；也可能是单调非严格递增，即存在连续的相等子序列。 源码中的二分查找：若返回正数，则找到 target 并返回索引；若没有找到 target，则返回 target 应该处于的索引位置（首个大于 target 的元素的索引位置）的取反。但是此种方法要求数组严格单调
论学二分查找的感悟
qq_50917103的博客
10-23 1281
二分算法应该是算法海洋里比较简单的一个算法了吧。 但是我却花了两周多的时间才摸到了点皮毛 不过从无到有，总算是从一个算法小小白变成了小白，还是挺兴奋的。 不敢说已经踏进算法之门，但勉强算是看见了那恢弘的轮廓。 希望那些和我一样，走在路上的，以及准备动身的人，能够坚持走下去，走近，走进。 门内有你我所愿之光景。 跑偏了跑偏了，言归正传，说说我对二分查找的总结。 一、二分查找的基础概念 首先，老生常谈，二分查找也成折半查找(Binary Search),是一种效率较高的查找方法，但是二.
算法分析与设计实验报告——二分搜索算法的实现
千色千寻的博客
02-02 7694
算法分析与设计实验报告——二分搜索算法的实现 目录：算法分析与设计实验报告——二分搜索算法的实现一、 实验目的二、实验要求三、 实验原理四、 实验过程(步骤)五、 运行结果六、实验分析与讨论七、实验特色与心得附件一 实验过程(步骤)附件二 运行结果 一、 实验目的 掌握分治法的基本思想，建立算法复杂度的理论分析与实验分析的联系，深刻体会算法复杂度作为算法的好坏评价指标的本质含义。 二、实验要求 用c++语言实现二分搜索算法，分析时间复杂性。实现二分搜索的递归与非递归程序，并进行跟踪分析其执行过程，体会两者
二分查找总结
lmq280492的博客
11-06 1604
这篇文章写得太好了！特予转载！ 原文链接：https://blog.csdn.net/sinat_30973431/article/details/103476360 一、概述 1、定义 二分查找是一种广泛使用的搜索算法，主要用于在有序数组（一般是升序，后面的内容也只是针对升序情况）上查找元素 2、主要思想 二分查找算法背后的主要思想是充分利用元素之间的有序性、以及数组的随机访问特性，每次都与查找区间的中间元素比较大小，根据比较结果不断将查找范围缩小一半（采用分治策略，剪枝？），直到元素被找到，
Java经典排序算法之二分插入排序详解
08-30
总结起来，二分插入排序是基于插入排序的优化策略，通过二分查找减少查找插入位置的时间，提高了效率，尤其在数据部分有序的情况下表现优秀。然而，对于大规模且无序的数据，其他更高效的排序算法如快速排序、归并...
分治法实现二分搜索(c语言)
01-03
二分搜索，也被称为折半查找，是一种...总结来说，二分搜索是利用分治法在有序数组中查找元素的一种高效算法，其C语言实现通常涉及递归或迭代的过程。在实际编程中，理解并熟练运用二分搜索可以极大地提高代码的性能。
二分查找算法题个人总结
最新发布
01-04
二分查找算法是一种高效的数据搜索方法，常用于已排序的数组或列表中。它通过不断缩小搜索范围，将目标元素定位到正确的位置。在本文中，我们将深入探讨二分查找的几种常见变体，以及如何根据不同的问题需求来选择...
C++实现旋转数组的二分查找
09-04
总结来说，C++实现旋转数组的二分查找需要考虑旋转对查找的影响，并根据数组的局部顺序调整搜索策略。通过这种优化，我们可以在旋转数组上保持较高的查找效率。这种问题的解决方案展示了动态调整搜索策略的重要性，...
二分搜索总结
cunane的博客
02-24 148
BinarySearch题目汇总： LintCode - Binary Search temp笔记
二分搜索算法总结
bigem的博客
02-18 804
二分搜索算法总结 算法框架 二分查找并不简单，Knuth 大佬（发明 KMP 算法的那位）都说二分查找：思路很简单，细节是魔鬼。很多人喜欢拿整型溢出的 bug 说事儿，但是二分查找真正的坑根本就不是那个细节问题，而是在于到底要给 mid 加一还是减一，while 里到底用 <= 还是 <。 二分查找根据搜索区间分类有两种情况： 「搜索区间」是 [left, right] ： ​ right = nums.length - 1 ​ while (left <= right) ​ left
二分查找各种情况大总结
热门推荐
yefengzhichen的博客
08-30 3万+
二分查找多次刷题时遇到，虽然每次也能写对，但花了蛮多时间，没好好想过。而且网上的太多版本，并不是很简洁，而且边界条件变化情况太多，容易混淆，下面是自己对二分查找的一些思考和总结，尽量写得简单易懂。 三种基本版本： 1.1 二分查找原始版--查找某个数的下标（任意一个） 在有序数组中查找某个数，找到返回数的下标，存在多个返回任意一个即可，没有返回-1。所有程序采用左右均为闭区间。典型代
算法系列——二分查找算法及其变体总结
BridgeGeorge
12-18 1733
基础二分查找只能找到指定target在序列中的位置，假如target有重复值，二分查找只能返回其中某个target的位置，这个位置并不确定，主要跟target值的起始位置和重复序列的长度有关系。
二分查找最详细的总结
DeepLearner的博客
09-04 812
二分查找详解 二分查找主要有三种变形，找出任意一个相等的元素，找出相等元素的左边界，找出相等元素的右边界（这里还有一种取巧办法，只要找比要找的元素target大一的最左边界的位置减一即可）。 而二分查找又需要注意搜索区间是左闭右开还是全闭区间，因此延伸出循环的结束条件以及在不同条件下如何更新区间，还有最后的返回值的问题，这些都是依赖于搜索区间的。 接下来为了说清楚上面需要考虑的问题，我会首先使用大家最常用的左闭右开区间为例，之后再给出闭区间版本（更简单，好用）。 一、基础版：找出任意一个相等元素的位置 这个
二分查找练习——leetcode 34. 在排序数组中查找元素的第一个和最后一个位置
qq_35299223的博客
10-03 659
leetcode 34. 在排序数组中查找元素的第一个和最后一个位置 给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。 你的算法时间复杂度必须是 O(log n) 级别。 如果数组中不存在目标值，返回 [-1, -1]。 示例 1: 输入: nums = [5,7,7,8,8,10], target = 8 输出: [3,4] 示例...
Algorithm终稿181
08-08
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对 3. 针对所有的元素重复以上的步骤，除了最后一个 4. 持续每次对越来越少的元素重复上面的步骤

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值