算法与数据结构：二分查找与跳跃表

已于 2024-05-16 16:10:06 修改
阅读量722 收藏 20
点赞数 26
分类专栏： 数据结构与算法 文章标签： 数据结构
于 2024-05-16 15:17:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58240849/article/details/138866759
版权

   ACM大牛带你玩转算法与数据结构-课程资料

 本笔记属于船说系列课程之一，课程链接：

哔哩哔哩_bilibiliicon-default.png?t=N7T8https://www.bilibili.com/cheese/play/ep66799?csource=private_space_class_null&spm_id_from=333.999.0.0

你也可以选择购买『船说系列课程-年度会员』产品『船票』，畅享一年内无限制学习已上线的所有船说系列课程：船票购买入口icon-default.png?t=N7T8https://www.bilibili.com/cheese/pages/packageCourseDetail?productId=598

做题网站OJ：HZOJ - Online Judge

Leetcode :力扣 (LeetCode) 全球极客挚爱的技术成长平台

 二分查找

        二分查找是一种在有序数组中查找特定元素的高效算法。它通过逐步缩小查找范围，将问题规模减半，最终找到目标元素或确定其不存在。二分查找的时间复杂度为 O(log_{2}n)。

        

        对于二分查找最基本的一个用法，对于一个有序数组查找元素：

        下图中分别是数组中元素和索引，对于下面的数组查找元素7

        第一步初始化确定查找区间的起始和终点

        然后计算中点：

        然后对于该位置和查找元素比较：

        然后继续重复上面的操作：    

        现在对比，然后通过判断可以确定查找元素在中点的左半区域，那么tail = mid - 1，同理上面的：

        然后继续重复操作：
        

        最后：

        对于大概过程了解了，下面就是对于这个过程的代码实现：
        

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
using namespace std;

#define swap(a, b) {\
    __typeof(a) _a = a;\
    a = b;\
    b = _a;\
}

int binary_search(int *arr, int n, int x) {
    //找到起点和终点
    int head = 0, tail = n - 1, mid; 
    //重复操作
    while (tail >= head) {
        //确定中点位置
        mid = (head + tail) / 2;
        //数组为单调递增
        //如果查找元素大于中点，说明元素在中点右半区域,所以舍弃左半区域和中点
        if (arr[mid] < x) head = mid + 1;
        //如果查找元素小于中点，说明元素在中点左半区域,所以舍弃左半区域和中点
        else if (arr[mid] > x) tail = mid - 1;
        //找到元素，返回元素索引
        else return mid;
    }
    //说明没有找到返回-1
    return -1;
}

void output(int *arr, int n) {
    for (int i = 0; i < n; i++) {
        i && printf(" ");
        printf("%d", arr[i]);
    }
    putchar(10);
    return ;
}

int mid_num(int a, int b, int c) {
    if (a > b) swap(a, b);
    if (a > c) swap(a, c);
    if (b > c) swap(b, c);
    return b;
}

//将数组使用快速排序，使数组成为递增序列
void my_sort(int *arr, int l, int r) {
    while (r > l) {
        if (r - l <= 2) {
            if (r - l <= 1) return ;
            if (arr[l] > arr[l + 1]) swap(arr[l], arr[l + 1]);
        }
        int x = l, y = r - 1;
        int z = mid_num(arr[x], arr[y], arr[(x + y)>>1]);
        do {
            while (arr[x] < z) ++x;
            while (arr[y] > z) --y;
            if (x <= y) {
                swap(arr[x], arr[y]);
                ++x, --y;
            }
        } while(x <= y);
        my_sort(arr, l, x);
        l = x;
    }
}

int main() {
    srand(time(0));
    #define MAX_N 10
    int arr[MAX_N + 5];
    for (int i = 0; i < MAX_N; i++) arr[i] = rand() % 100;
    my_sort(arr, 0, MAX_N);
    output(arr, MAX_N);
    int x;
    while (~scanf("%d", &x)) {
        if (x == -1) break;
        printf("%d is at arr %d\n", x, binary_search(arr, MAX_N, x));
    }
    return 0;
}

 跳跃表

        链表的查找、插入和删除的时间复杂度是O(n)的，为了降低这个时间复杂度那么就有了跳跃表的出现，跳跃表是基于链表的升级。

下图是一个跳跃表的图展示结构：

         通过图中跳跃表是由链表组成的，设计跳跃表我们会用到节点，那么我们就先创建节点。

数据分析：

注意：在设计跳跃表时，头指针的位置永远在，左上角，而头指针的高度就是跳跃表中元素最高的高度而不是跳跃表限制的高度。

分析节点需要什么变量：

  • key值表示节点存储的值            
  • 存储指向的下一个节点的地址的指针
  • 存储指向上下节点的地址指针
  • 每个节点当前的level值
typedef struct Node {
    int key, level;
    struct Node *next, *down, *up;
} Node;

        对于节点初始化操作，他处的节点可能不止一个所以在初始化时，就初始化拥有level层的节点。   

Node *getNewNode(int key, int n) {
    Node *nodes = (Node *)malloc(sizeof(Node) * n);
    //这里是初始化的一列的节点
    //然后这一列节点是从上到下相互指向的,也就是双向链表
    for (int i = 0; i < n; i++) {
        nodes[i].key = key;
        nodes[i].level = i;
        nodes[i].next = NULL;
        nodes[i].down = (i ? nodes + (i - 1) : NULL);
        nodes[i].up = (i + 1 < n ? nodes + (i + 1) : NULL);
    }
    return nodes + n - 1;
}

        通过初始化的新节点是当前节点最顶上的节点的地址。

        创建完成节点后，那么就开始创建跳跃表的数据结构：

  •  头节点和尾节点指针
  • 跳跃表最高限制level层数
typedef struct Skiplist {
    Node *head, *tail;
    int max_level;
} Skiplist;

        跳跃表初始化操作：

Skiplist *getNewSkiplist(int n) {
    Skiplist *s = (Skiplist *)malloc(sizeof(Skiplist));
    s->head = getNewNode(INT32_MIN, n);
    s->tail = getNewNode(INT32_MAX, n);
    s->max_level = n;
    Node *p = s->head, *q = s->tail;
    //使头节点去指向尾节点
    while (p) {
        p->next = q;
        p = p->down, q = q->down;
    }
    //使头节点指向当前跳跃表最左上方的节点
    //那么现在就应该是level 0层第一个的节点
    while (s->head->level != 0) s->head = s->head->down;
    return s;
}

        有了在堆区的开辟空间，那么就需要释放空间，对于跳跃表的释放操作：
        

void clearNode(Node *p) {
    if (p == NULL) return ;
    free(p);
    return ;
}

void clearSkiplist(Skiplist *s) {
    Node *p = s->head, *q;
    while (p->level != 0) p = p->down;
    while (p) {
        q = p->next;
        clearNode(p);
        p = q;
    }
    free(s);
    return ;
}

        操作：

        查找：

        

        需要知道的是头指针指向的是，跳跃表的最坐上角的节点，不是跳跃表限制高度位置，而是跳跃表中的节点最高的位置，然后所在的列就是负无穷的那一列。

        现在明确了头指针的位置，如何去查找，可以知道跳跃表里的元素是有序的，这里是一个递增的序列，那么先从头指针的那行去找，从左向右。当查找时，如果下个元素大于查找的值就跳到下层去找说明层没有查找的元素，如果小于等于就往右去找。

         具体过程就不去模拟了，下面是代码实现：

Node *find(Skiplist *s, int x) {
    Node *p = s->head;
    //先从左往右找，知道碰到后边界往下
    //往下后，又循环上面的语句
    //直到没有下层或者找到节点
    while (p && p->key != x) {
        //说明该层后面还有节点，就往后找
        if (p->next->key <= x) p = p->next;
        //说明当层没有找到对应的节点
        else p = p->down;
    }
    return p;
}
 插入：

        插入的时候需要处理：

  • 随机高度：通过随机值来处理
  • 和节点插入：先找到插入前一个节点的位置，而且可能每层的节点前一个节点不一样这是需要考虑的，如果插入节点的值比当前节点下一个节点大，那就继续往后，直到当前节点的下一个节点值比插入节点的值大，开始插入操作；
  • 跳跃表头指针的高度：如果新插入节点的高度比之前跳跃表中的头指针的高度高，需要重置头指针的位置，并且不能超过跳跃表限制高度

        下面是代码实现：

        

double randDouble() {
    #define MAX_RAND_N 1000000
    return (rand() % MAX_RAND_N) * 1.0 / MAX_RAND_N;
    #undef MAX_RAND_N
}

int randLevel(Skiplist *s) {
    int level = 1;
    double p = 1.0 / 2.0;
    while (randDouble() < p) level += 1;
#define min(a, b) ((a) < (b) ? (a) : (b))
    return min(s->max_level, level);
#undef min
}

void insert(Skiplist *s, int x) {
    //获取随机高度
    int level = randLevel(s);
    //使头指针的高度要高于添加节点的高度
    while (s->head->level + 1 < level) s->head = s->head->up;
    //当前node的位置是指向最顶点的节点的
    Node *node = getNewNode(x, level);
    Node *p = s->head;
    //是当头指针的高度和添加节点的高度相同
    while (p->level != node->level) p = p->down;
    while (p) {
        //因为是要插入节点操作
        //插入时是需要前一个节点的，所以需要判断后一个节点
        //因为边界是无穷大的，所以不用判短指针为空的操作
        while (p->next->key < node->key) p = p->next;
        //插入操作
        node->next = p->next;
        p->next = node;
        //插入完成向下层继续插入操作
        p = p->down;
        node = node->down;
    }
    return ;
}
删除：

        删除操作需要的处理：

  • 判断值是否在跳跃表中：通过查找操作
  • 如何找到删除节点的前一个节点：和插入操作一样的去处理；
int erase(Skiplist *s, int key) {
    Node *p = find(s, key);
    //p为空说明没有这个值
    if (!p) return 0;
    //说明找到了
    Node *q = s->head;
    //使指针指向，需要删除节点的最高层
    //find返回值就是最高层节点的指针
    while (q->level != p->level) q = q->down;
    //开始找对应值的前一个节点
    //并开始删除操作
    while (q) {
        //找到一个节点的下一个节点的值大于等于当前值
        while (q->next->key < key) q = q->next;
        //目前节点是满足上面的条件的
        //如果等于key值说明需要删除
        if (key == q->next->key) {
            q->next = q->next->next;
        } 
        //不等于就往下层走
        q = q->down;
    }
    return 1;
}

整段代码：

#include<iostream>
using namespace std;
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
#include <time.h>

typedef struct Node {
    int key, level;
    struct Node *next, *down, *up;
} Node;


typedef struct Skiplist {
    Node *head, *tail;
    int max_level;
} Skiplist;

Node *getNewNode(int key, int n) {
    Node *nodes = (Node *)malloc(sizeof(Node) * n);
    //这里是初始化的一列的节点
    //然后这一列节点是从上到下相互指向的,也就是双向链表
    for (int i = 0; i < n; i++) {
        nodes[i].key = key;
        nodes[i].level = i;
        nodes[i].next = NULL;
        nodes[i].down = (i ? nodes + (i - 1) : NULL);
        nodes[i].up = (i + 1 < n ? nodes + (i + 1) : NULL);
    }
    return nodes + n - 1;
}

Skiplist *getNewSkiplist(int n) {
    Skiplist *s = (Skiplist *)malloc(sizeof(Skiplist));
    s->head = getNewNode(INT32_MIN, n);
    s->tail = getNewNode(INT32_MAX, n);
    s->max_level = n;
    Node *p = s->head, *q = s->tail;
    //使头节点去指向尾节点
    while (p) {
        p->next = q;
        p = p->down, q = q->down;
    }
    //使头节点指向当前跳跃表最左上方的节点
    //那么现在就应该是level 0层第一个的节点
    while (s->head->level != 0) s->head = s->head->down;
    return s;
}

Node *find(Skiplist *s, int x) {
    Node *p = s->head;
    //先从左往右找，知道碰到后边界往下
    //往下后，又循环上面的语句
    //直到没有下层或者找到节点
    while (p && p->key != x) {
        //说明该层后面还有节点，就往后找
        if (p->next->key <= x) p = p->next;
        //说明当层没有找到对应的节点
        else p = p->down;
    }
    return p;
}

double randDouble() {
    #define MAX_RAND_N 1000000
    return (rand() % MAX_RAND_N) * 1.0 / MAX_RAND_N;
    #undef MAX_RAND_N
}

int randLevel(Skiplist *s) {
    int level = 1;
    double p = 1.0 / 2.0;
    while (randDouble() < p) level += 1;
#define min(a, b) ((a) < (b) ? (a) : (b))
    return min(s->max_level, level);
#undef min
}

void insert(Skiplist *s, int x) {
    //获取随机高度
    int level = randLevel(s);
    //使头指针的高度要高于添加节点的高度
    while (s->head->level + 1 < level) s->head = s->head->up;
    //当前node的位置是指向最顶点的节点的
    Node *node = getNewNode(x, level);
    Node *p = s->head;
    //是当头指针的高度和添加节点的高度相同
    while (p->level != node->level) p = p->down;
    while (p) {
        //因为是要插入节点操作
        //插入时是需要前一个节点的，所以需要判断后一个节点
        //因为边界是无穷大的，所以不用判短指针为空的操作
        while (p->next->key < node->key) p = p->next;
        //插入操作
        node->next = p->next;
        p->next = node;
        //插入完成向下层继续插入操作
        p = p->down;
        node = node->down;
    }
    return ;
}


void clearNode(Node *);
int erase(Skiplist *s, int key) {
    Node *p = find(s, key);
    //p为空说明没有这个值
    if (!p) return 0;
    //说明找到了
    Node *q = s->head;
    //使指针指向，需要删除节点的最高层
    //find返回值就是最高层节点的指针
    while (q->level != p->level) q = q->down;
    //开始找对应值的前一个节点
    //并开始删除操作
    while (q) {
        //找到一个节点的下一个节点的值大于等于当前值
        while (q->next->key < key) q = q->next;
        //目前节点是满足上面的条件的
        //如果等于key值说明需要删除
        if (key == q->next->key) {
            q->next = q->next->next;
        } 
        //不等于就往下层走
        q = q->down;
    }
    return 1;
}

void clearNode(Node *p) {
    if (p == NULL) return ;
    free(p);
    return ;
}

void clearSkiplist(Skiplist *s) {
    Node *p = s->head, *q;
    while (p->level != 0) p = p->down;
    while (p) {
        q = p->next;
        clearNode(p);
        p = q;
    }
    free(s);
    return ;
}

void output(Skiplist *s) {
    Node *p = s->head;
    int len = 0;
    for (int i = 0; i <= s->head->level; i++) {
        len += printf("%4d", i);
    }
    printf("\n");
    for (int i = 0; i < len; i++) printf("-");
    printf("\n");
    while (p->level > 0) p = p->down;
    while (p) {
        bool flag = (p->key != INT32_MIN && p->key != INT32_MAX);
        for (Node *q = p; flag && q; q = q->up) {
            printf("%4d", q->key);
        }
        if (flag) printf("\n");
        p = p->next;
    }
    return ;
}


int main() {
    srand(time(0));
    int x;
#define MAX_LEVEL 32
    Skiplist *s = getNewSkiplist(MAX_LEVEL);
#undef MAX_LEVEL
    // insert
    while (~scanf("%d", &x)) {
        if (x == -1) break;
        insert(s, x);
        output(s);
    }
    output(s);
    // erase
    while (~scanf("%d", &x)) {
        if (x == -1) break;
        if (erase(s, x)) {
            output(s);
        } else {
            printf("No Find\n") ;
        }
    }
    clearSkiplist(s);
    return 0;
}
初猿°
关注
  • 26
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构与算法——顺序表 (完整代码)
zz137955的博客
10-31 1915
基于语言实现数据结构第一节——顺序表 增删查改
leetcode跳跃-algorithm:算法
06-30
二分查找 树的前序、中序、后续遍历 第四部分 剑指offer的算法题目 第五部分(yxxxx.mxx.dxx) 后续的包打算以年为单位，以yxxxx.mxx.dxx的方式更新每天做的leetcode题目，目前从简单的题目开始刷
数据结构与算法之跳跃表
LInthunder的博客
06-06 574
数据结构与算法系列文章 数据结构与算法之哈希表 数据结构与算法之十大经典排序 数据结构与算法之跳跃表 目录数据结构与算法系列文章数据结构与算法之哈希表数据结构与算法之十大经典排序数据结构与算法之跳跃表 ...
数据结构与算法分析：（九）二分查找算法
riemann_的博客
03-20 2008
一、前言 二分查找算法是针对有序数据集合的查找算法，将原本时间复杂度是线性时间提升到了对数时间范围，大大缩短了搜索时间。二分查找算法的思想非常简单，但细节是魔鬼。也就是你想写成没有bug的二分查找算法很难，出错原因主要集中在判定条件和边界值的选择上，很容易就会导致越界或者死循环的情况。 1、思想 二分查找又称折半查找，它是一种效率较高的查找方法。折半查找的算法思想是将数列按有序化(递增或递减)排列...
高级数据结构与算法 | 跳跃表（Skip List）
凌桓丶的博客
09-09 1137
文章目录区间查询时链表与顺序表的局限跳表=链表+索引跳表的原理晋升插入删除跳表的实现跳表VS红黑树 区间查询时链表与顺序表的局限 假设有这样一个情景， 此时需要设计一个拍卖系统，对于商品的展示需要支持按照价格、销量、好评、拍卖人编号等方式进行排序，并且还需要支持按照名字的精确查询以及不需要名字的全量查询。 拍卖行商品的列表是线性的，那么首选的数据结构应该就是线性结构中的链表和顺序表。 假设此时是一个按照价格进行排序的集合 如果此时使用的是一个顺序表，当有商品插入时首先就要确认其插入的位置，因为顺序表支持下
【超全汇总】学习数据结构与算法，计算机基础知识，看这篇就够了
热门推荐
帅地
01-18 10万+
由于文章有点多，并且发的文章也不是一个系列一个系列发的，不过我的文章大部分都是围绕着 数据结构 + 算法 + 计算机网络 + 操作系统 + Linux + 数据库 这几个方面发的，为了方便大家阅读，我整理了一波。不过公众号可以说是不支持修改文章，因为我决定每两三个月就整理一次，会非常详细着按照类别整理出来哦，并且也给出了目录哦。大家记得多看看哦，好多文章都是面试中常问滴 文章目录一、经验/经历/所...
数据结构与算法：排序（分类）
Viadimir的博客
05-21 1019
一、分类概述 1.排序：它是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。 具体定义为： 假设含n个记录的序列为 { R1, R2, …， Rn } ， 其相应的关键字序列为 { K1, K2, …，Kn }， 这些关键字相互之间可以进行比较，即在它们之间 存在着这样一个关系：Kp1≤Kp2≤…≤Kpn 按此固有关系将记录序列 { R1, R2, …， Rn } 重新排列为 { Rp1, Rp2, …，Rpn } 的过程称作 分类。 2.内部分类和外部分类
【数据结构与算法】顺序表
joy.728的博客
10-09 931
顺序表的超详细介绍！！！希望你也能学会！！！ 🎇🎇🎇每个优秀的人都有一段沉默的时光，那段时光是付出了很多努力却得不到结果的日子，我们把它叫做扎根。🎇🎇🎇
数据结构导论【六】之 查找表
吴小迪的博客
11-08 1492
感谢内容提供者：金牛区吴迪软件开发工作室 接上一篇：数据结构导论【五】之 图 文章目录一、基本概念二、静态查找表的实现1.顺序表上的查找 -- 顺序查找a.过程b.算法c.算法分析2.有序表上的查找 -- 二分查找a.二分查找思想b.二分查找过程c.二分查找算法d.例：（在下列有序顺序表中查找 K = 18）e.算法分析3.索引顺序表的查找 -- 分块查找a.查找过程b.例c.算法分析三、动态查找表（二叉排序树）1.二叉排序树2.二叉排序树上的查找a.过程b.二叉排序树查找算法c.二叉排序树的插入和生成.
数据结构与算法(6)哈希表
weixin_63714970的博客
03-01 1464
数据结构与算法(6)哈希表
算法：常用算法和数据结构讲解，面试算法题leetcode解题，提供golangjs版本
02-02
跳表是一个随机化的数据结构，实质上就是一种可以进行二分查找的有序链表。跳表在很大程度上的有序链表上面增加了多级索引，通过索引来实现快速查找。跳表多个能提高搜索性能，同时也可以提高插入和删除操作的性能。...
鸿蒙轻内核A核源码分析系列二 数据结构-位图操作
maniuT的博客
06-11 1040
位操作模块提供对32位无符号整数数值的bit位进行操作，bit位取值为0-31，以0开始计算，从左向右，第0位，第1位。。。第31位等。⑴处定义的宏如下，也就是十进制31。如果传入的比特位pos大于31，会通过逻辑与运算截断，只取低5位，确保不会大于31，避免溢出。⑵处定义的位图掩码全是1。在文件中定义了常用的位操作相关的宏。宏根据参数x计算出需要操作第几个状态字，由于计算状态字的使用的是UINTPTR，状态字可以是32位、也可以是64位。后文，我们默认以32位进行讲解。宏传入的参数是位操作的开始bit。
数据结构--第七章--树和二叉树
2302_80052051的博客
06-11 315
前序+中序可以确定一个二叉树；中序+后序可以确定一个二叉树。，将数据元素组织成层次结构，元素间属于。二叉树的定义是递归定义。
数据结构--线性表和串
code袁的博客
06-08 815
🦁作者简介：一名喜欢分享和记录学习的在校大学生💥个人主页code袁💥个人QQ🐯个人wechat：code8896线性表是一种常见的数据结构，它是具有相同数据类型的有限序列。线性表中的元素之间存在一种顺序关系，可以通过元素在表中的位置来访问和操作。串是由零个或多个字符组成的有限序列，也可以理解为字符串。串是计算机科学中最基本的数据类型之一，常用于表示文本信息。手动码字，如有错误，欢迎在评论区指正💬~你的支持就是我更新的最大动力💪~
数据结构 -- 树状数组
gghhb12的博客
06-09 1252
树状数组或二叉索引树（Binary Indexed Tree），又以其发明者命名为 Fenwick 树。其初衷是解决数据压缩里的累积频率的计算问题，现多用于高效计算数列的前缀和、区间和。它可以以 O(logn) 的时间得到任意前缀和。并同时支持在 O(logn) 时间内支持动态单点值的修改。空间复杂度 O(n)。具体区别和联系如下：1.两者在复杂度上同级, 但是树状数组的常数明显优于线段树, 其编程复杂度也远小于线段树.
【算法与数据结构】【数组篇】【题6-题10】
最新发布
handsomethefirst的博客
06-11 1169
首先，是一个递增排序，那么我们可以知道头尾相加，判断最大值和最小值的和是否等于目标值，如果大于目标值，则说明我们值找大了，那就要找到次第二最大值，作为新区间的最大值，然后继续判断是否等于目标值。当为偶数的时候，如果x+y=i，i的值小于最大的行数，代表坐标x从i开始，y从0开始，如果i大于等于最大的行数，代表坐标x从m开始，y=i-m开始。当为奇数的时候，如果x+y=i，i的值小于最大的列数，代表坐标y从i开始，x从0开始, 如果i大于等于最大的列数，代表坐标y从n开始，x=i-n开始。
牛客网刷题 | BC117 逆序输出
m0_64000959的博客
06-09 550
目前主要分为三个专栏，后续还会添加： 专栏如下： C语言刷题解析 C语言系列文章 我的成长经历感谢阅读！初来乍到，如有错误请指出，感谢！输入10个整数，要求按输入时的逆序把这10个数打印出来。逆序输出，就是按照输入相反的顺序打印这10个数。一行，输入10个整数（范围-231~231-1），用空格分隔。一行，逆序输出输入的10个整数，用空格分隔。使用数组的方法将用户输入的数字存起来然后使用数组将它打印出来 自减的方式 代码 2 ：
二分查找算法（数据结构）
12-05
二分查找算法，也称折半查找算法，是一种在有序数组中查找某一特定元素的搜索算法。该算法的时间复杂度为O(log n)。 以下是二分查找算法的实现步骤： 1. 确定数组的左右边界，即最小下标和最大下标。 2. 计算数组的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

初猿°

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

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

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

打赏作者

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

抵扣说明：

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

余额充值