数据结构实验二之线性表（上）

最新推荐文章于 2024-10-14 16:55:09 发布
最新推荐文章于 2024-10-14 16:55:09 发布
阅读量1k 收藏 22
点赞数 27
分类专栏： 数据结构实验 文章标签： 数据结构 C++ 顺序表 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014114223/article/details/142379810
版权

实验题1：实现顺序表的各种基本运算的算法

题目描述

编写一个程序sqlist.cpp,实现顺序表的各种基本运算和整体建表异法(假设顺序表的元素类型 Elem Type为char),并在此基础上设计一个程序exp2-1.cpp完成以下功能。

(1)初始化顺序表L。

(2)依次插入元素a、b、c、d、e。

(3)输出顺序表L。

(4)输出顺序表L的长度。

(5)判断顺序表L 是否为空。

(6)输出顺序表L的第3个元素。

(7)输出元素a的位置。

(8)在第4个元素的位置上插入元素f。

(9)输出顺序表L。

(10)删除顺序表L的第3个元素。

(11)输出顺序表L。

(12)释放顺序表L。

sqlist.cpp程序,其中包含如下函数：

· InitList(SqList*&L):初始化顺序表L。

· DestroyList(SqList*L):释放顺序表L。

· ListEmpty(SqList*L.):判断顺序表L是否为空表。

· ListLength(SqList *L):返回顺序表L中的元素个数。

· DispList(SqList*L):输出顺序表L。

·GetElem(SqList *L,int i,ElemType &e):获取顺序表L中的第i个元素。

· LocateElem(SqList *L.ElemType e):在顺序表L中查找元素e。

· ListInsert(SqList*&L,inti,ElemType e):在顺序表L中的第i个位置上插入元素c。

· ListDelete(SqList*&L,int i,ElemType &e):从顺序表L中删除第i个元素。

运行代码

sqlict.cpp
#include <iostream>
#include<malloc.h>
using namespace std;
#define MAXSIZE 100
typedef char ElemType;
typedef struct {
    ElemType data[MAXSIZE];
    int length;
} SqList;//表明表的类型
//整体建立顺序表
void GreateList(SqList* L, ElemType a[], int n) {
    L = (SqList*)malloc(sizeof(SqList));
    for (int i = 0; i < n; i++)
        L->data[i] = a[i];
    L->length = n;
}
// 初始化顺序表 L
void InitList(SqList* L) {
    L = (SqList*)malloc(sizeof(SqList));
    L->length = 0;
}
// 释放顺序表 L
void DestroyList(SqList*& L) {
    delete L;
}
// 判断顺序表 L 是否为空表
bool ListEmpty(SqList* L) {
    return L->length == 0;
}
// 返回顺序表 L 中的元素个数
int ListLength(SqList* L) {
    return L->length;
}
// 输出顺序表 L
void DispList(SqList* L) {
    for (int i = 0; i < L->length; i++) {
        cout << L->data[i] << " ";
    }
    cout << endl;
}
// 获取顺序表 L 中的第 i 个元素
bool GetElem(SqList* L, int i, ElemType& e) {
    if (i < 1 || i > L->length) {
        return false;
    }
    e = L->data[i - 1];
    return true;
}
// 在顺序表 L 中查找元素 e
int LocateElem(SqList* L, ElemType e) {
    for (int i = 0; i < L->length && L->data[i] != e; i++) {
        if (i > L->length)
            return 0;
        else
            return i + 1;
    }
    return 0;
}
// 在顺序表 L 中的第 i 个位置上插入元素 e
bool ListInsert(SqList*& L, int i, ElemType e) {
    if (i < 1 || i > L->length + 1 || L->length == MAXSIZE) {
        return false;
    }
    for (int j = L->length; j >= i; j--) {
        L->data[j] = L->data[j - 1];
    }
    L->data[i - 1] = e;
    L->length++;
    return true;
}
// 从顺序表 L 中删除第 i 个元素
bool ListDelete(SqList*& L, int i, ElemType& e) {
    if (i < 1 || i > L->length) {
        return false;
    }
    e = L->data[i - 1];
    for (int j = i; j < L->length; j++) {
        L->data[j - 1] = L->data[j];
    }
    L->length--;
    return true;
}
 exp2-1.cpp
#include <iostream>
#include "sqlist.cpp"
using namespace std;
int main() {
    SqList* L;
    cout << "顺序表的基本运算如下:" << endl;
    cout << "  (1)初始化顺序表L:" << endl;
    InitList(L);
    cout << "  (2)依次插入元素a,b,c,d,e:" << endl;
    ListInsert(L, 1, 'a');
    ListInsert(L, 2, 'b');
    ListInsert(L, 3, 'c');
    ListInsert(L, 4, 'd');
    ListInsert(L, 5, 'e');
        cout << "  (3)输出顺序表L:";
    DispList(L);
    cout << "  (4)顺序表 L 的长度为：" << ListLength(L) << endl;
    cout << "  (5)判断顺序表 L 是否为空：" << (ListEmpty(L) ? "是" : "否") << endl;
    ElemType e;
    GetElem(L, 3, e);
    cout << "  (6)顺序表 L 的第 3 个元素为：" << e << endl;
    cout << "  (7)元素 a 的位置为：" << LocateElem(L, 'a') << endl;
    cout << "  (8)在第4个元素位置上插入元素f" << endl;
    ListInsert(L, 4, 'f');
    cout << "  (9)插入元素 f 后的顺序表 L 为：";
    DispList(L);
    cout << "  (10)删除第 3 个元素：" << endl;
    ListDelete(L, 3, e);
    cout << "  (11)输出顺序表 L ：";
    DispList(L);
    cout << "  (12)释放顺序表 L ：" << endl;
    DestroyList(L);
    return 1;
}

代码结果与思路

  1. GreateList 函数:该函数用于整体建立顺序表。

    • 首先动态分配一个 SqList 类型的内存空间，并将其地址赋给传入的指针 L。
    • 然后通过循环将给定的数组 a 中的元素逐个复制到新创建的顺序表 L 的 data 数组中。
    • 最后设置顺序表的长度为传入的数组元素个数 n。

  2. InitList 函数:用于初始化顺序表。

    • 动态分配一个 SqList 类型的内存空间，并将其地址赋给传入的指针 L。
    • 将顺序表的长度初始化为 0。

  3. DestroyList 函数:释放顺序表所占用的内存空间。使用 delete 操作符释放传入的指针 L 所指向的内存。

  4. ListEmpty 函数:判断顺序表是否为空表。通过检查顺序表的长度是否为 0 来确定顺序表是否为空。

  5. ListLength 函数:返回顺序表中的元素个数。直接返回顺序表的长度属性。

  6. DispList 函数输出顺序表中的所有元素。通过循环遍历顺序表的 data 数组，逐个输出其中的元素。

  7. GetElem 函数:获取顺序表中指定位置的元素。

    • 首先检查传入的位置参数 i 是否合法（大于等于 1 且小于等于顺序表长度）。
    • 如果合法，将顺序表中对应位置的元素赋值给传入的引用参数 e，并返回 true；否则返回 false。

  8. LocateElem 函数

    • 在顺序表中查找指定元素的位置。
    • 通过循环遍历顺序表的 data 数组，逐个比较元素与查找的目标元素 e。
    • 如果找到目标元素，返回其位置（从 1 开始计数）；如果遍历完整个顺序表都未找到目标元素，返回 0。

  9. ListInsert 函数:在顺序表的指定位置插入元素。

    • 首先检查插入位置参数 i 是否合法（大于等于 1 且小于等于顺序表长度加 1，同时顺序表未满）。
    • 如果合法，通过循环将插入位置及之后的元素向后移动一位，为新元素腾出位置。
    • 将新元素插入到指定位置，更新顺序表的长度，并返回 true；否则返回 false。

  10. ListDelete 函数 :  从顺序表中删除指定位置的元素。首先检查删除位置参数 i 是否合法（大于等于 1 且小于等于顺序表长度）。如果合法，将指定位置的元素赋值给传入的引用参数 e。通过循环将删除位置之后的元素向前移动一位，覆盖被删除的元素。更新顺序表的长度，并返回 true；否则返回 false。

实验题2:实现单链表的各种基本运算的算法

题目描述

编写一个程序Linklist.cpp,实现单链表的各种基本运算和整体建表算法(假设单

链表的元素类型 ElemType为char)在此基础上设计一个程序exp2-2.cpp完成以下功能：

(1)初始化单链表h。

(2)依次采用尾插法插入元素a,b.c、d、e。

(3)输出单链表h。

(4)输出单链表h的长度。

(5)判断单链表h是否为空。

(6)输出单链表的第3个元素。

(7)输出元素a的位置。

(8)在第4个元素的位置上插入元素l。

(9)输出单链表人。

(10)删除单链表h的第3个元素。

(11)输出单链表系h。

(12)释放单链表为h。

Linklist.cpp程序,其中包含如下函数：

· InitList(LinkNode·&.L):初始化单链表L。

· DestroyList(LinkNode·L);释放单链表L。

· ListEmpty(LinkNode·L);判断单链表L.是否为空表。

· ListLength(LinkNode·L.);返同单链表L中的元素个数。

· DispList(LinkNode·L);输出单链表L。

· GetElem(LinkNode ·L.inti.ElemType &-e):获取单链表I中的第;个元素。

· LocateElem(LinkNode·L,ElemTypee);在单链表L中查找元素e。

· ListInsert(LinkNode·&L,inti.ElemTypee);在单链表L的第i个位置上插入元素w。

· ListDelete(LinkNode·8L.inti.ElemType &e):从单链表L.中删除第i个元素

运行代码

Linklist.cpp
#include <stdio.h>
#include <stdlib.h>

typedef char ElemType;
typedef struct LNode {
    ElemType data;
    struct LNode* next;
} LinkNode;

// 用头插法建立单链表
void CreateListF(LinkNode*& L, ElemType a[], int n) {
    LinkNode* s;
    L = (LinkNode*)malloc(sizeof(LinkNode));
    L->next = NULL;
    for (int i = 0; i < n; i++) {
        s = (LinkNode*)malloc(sizeof(LinkNode));
        s->data = a[i];
        s->next = L->next;
        L->next = s;
    }
}

// 用尾插法建立单链表
void CreateListR(LinkNode*& L, ElemType a[], int n) {
    LinkNode* s, * r;
    L = (LinkNode*)malloc(sizeof(LinkNode));
    L->next = NULL;
    r = L;
    for (int i = 0; i < n; i++) {
        s = (LinkNode*)malloc(sizeof(LinkNode));
        s->data = a[i];
        r->next = s;
        r = s;
    }
    r->next = NULL;
}

// 初始化线性表
void InitList(LinkNode*& L) {
    L = (LinkNode*)malloc(sizeof(LinkNode));
    L->next = NULL;
}

// 销毁线性表
void DestroyList(LinkNode*& L) {
    LinkNode* pre = L;
    LinkNode* p = pre->next;
    while (p != NULL) {
        free(pre);
        pre = p;
        p = pre->next;
    }
    free(pre);
}

// 判断线性表是否为空表
bool ListEmpty(LinkNode* L) {
    return (L->next == NULL);
}

// 求线性表的长度
int ListLength(LinkNode* L) {
    int i = 0;
    LinkNode* p = L;
    while (p->next != NULL) {
        i++;
        p = p->next;
    }
    return i;
}

// 输出线性表
void DispList(LinkNode* L) {
    LinkNode* p = L->next;
    while (p != NULL) {
        printf("%c ", p->data);
        p = p->next;
    }
    printf("\n");
}

// 求线性表中第 i 个元素的值
bool GetElem(LinkNode* L, int i, ElemType& e) {
    int j = 0;
    LinkNode* p = L;
    if (i <= 0) return false;
    while (j < i && p != NULL) {
        j++;
        p = p->next;
    }
    if (p == NULL) return false;
    else {
        e = p->data;
        return true;
    }
}

// 查找第一个值域为 e 的元素的序号
int LocateElem(LinkNode* L, ElemType e) {
    int i = 1;
    LinkNode* p = L->next;
    while (p != NULL && p->data != e) {
        p = p->next;
        i++;
    }
    if (p == NULL) return 0;
    else return i;
}

// 在单链表中第 i 个位置插入元素 e
bool ListInsert(LinkNode*& L, int i, ElemType e) {
    int j = 0;
    LinkNode* p = L;
    if (i <= 0) return false;
    while (j < i - 1 && p != NULL) {
        j++;
        p = p->next;
    }
    if (p == NULL) return false;
    else {
        LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
        s->data = e;
        s->next = p->next;
        p->next = s;
        return true;
    }
}

// 从单链表中删除第 i 个元素
bool ListDelete(LinkNode*& L, int i, ElemType& e) {
    int j = 0;
    LinkNode* p = L;
    LinkNode* q;
    if (i <= 0) return false;
    while (j < i - 1 && p != NULL) {
        j++;
        p = p->next;
    }
    if (p == NULL) return false;
    else {
        q = p->next;
        if (q == NULL) return false;
        e = q->data;
        p->next = q->next;
        free(q);
        return true;
    }
}
excp2-2.cpp
#include <stdio.h>
#include <stdlib.h>
#include "Linklist.cpp"

int main() {
    LinkNode* h;
    ElemType e;
    printf("单链表的基本运算如下:\n");
    printf("(1)初始化单链表 h\n");
    InitList(h);
    printf("(2)依次采用尾插法插入元素 a,b,c,d,e\n");
    ListInsert(h, 1, 'a');
    ListInsert(h, 2, 'b');
    ListInsert(h, 3, 'c');
    ListInsert(h, 4, 'd');
    ListInsert(h, 5, 'e');
    printf("(3)输出单链表 h:");
    DispList(h);
    printf("(4)单链表 h 长度:%d\n", ListLength(h));
    printf("(5)单链表 h 为%s\n", ListEmpty(h) ? "空" : "非空");
    GetElem(h, 3, e);
    printf("(6)单链表 h 的第 3 个元素:%c\n", e);
    printf("(7)元素 a 的位置:%d\n", LocateElem(h, 'a'));
    printf("(8)在第 4 个元素位置上插入元素 f\n");
    ListInsert(h, 4, 'f');
    printf("(9)输出单链表 h:");
    DispList(h);
    printf("(10)删除 h 的第 3 个元素\n");
    ListDelete(h, 3, e);
    printf("(11)输出单链表 h:");
    DispList(h);
    printf("(12)释放单链表 h\n");
    DestroyList(h);
    return 0;
}

代码结果与思路

  1. CreateListF（头插法建立单链表）

    • 首先为单链表创建一个头节点，并将其 next 指针初始化为 NULL。
    • 然后遍历给定的字符数组 a，对于数组中的每个元素，创建一个新的节点 s。
    • 将新节点 s 的 next 指针指向当前头节点的 next，然后将头节点的 next 指针指向新节点 s，实现头插法插入节点。

  2. CreateListR（尾插法建立单链表）

    • 同样先为单链表创建一个头节点，并将其 next 指针初始化为 NULL。同时定义一个指针 r 指向头节点，用于跟踪单链表的尾节点。
    • 遍历给定的字符数组 a，对于数组中的每个元素，创建一个新的节点 s。
    • 将新节点 s 插入到 r 所指节点的后面，然后更新 r 指向新的尾节点。最后将尾节点的 next 指针置为 NULL。

  3. InitList（初始化单链表）为单链表分配一个头节点的内存空间，并将头节点的 next 指针初始化为 NULL，表示单链表为空。

  4. DestroyList（销毁单链表）从单链表的头节点开始，遍历单链表，逐个释放每个节点的内存空间。使用两个指针 pre 和 p，pre 始终指向当前要释放的节点的前一个节点，p 指向当前要释放的节点。释放完一个节点后，移动指针继续释放下一个节点，直到遍历完整个单链表。

  5. ListEmpty（判断单链表是否为空表）检查单链表的头节点的 next 指针是否为 NULL，如果是，则表示单链表为空，返回 true；否则返回 false。

  6. ListLength（求单链表的长度）从单链表的头节点开始遍历单链表，使用一个计数器 i 记录节点的数量。当遍历到单链表的尾节点时，返回计数器的值，即为单链表的长度。

  7. DispList（输出单链表）从单链表的第一个数据节点开始遍历单链表，逐个输出每个节点的 data 域的值，直到遍历到单链表的尾节点。

  8. GetElem（求单链表中第 i 个元素的值）从单链表的头节点开始遍历单链表，使用一个计数器 j 记录当前遍历到的节点位置。当 j 等于 i 时，表示找到了第 i 个节点，将其 data 域的值赋给传入的引用参数 e，并返回 true；如果遍历完单链表还未找到第 i 个节点，则返回 false。

  9. LocateElem（查找第一个值域为 e 的元素的序号）从单链表的第一个数据节点开始遍历单链表，逐个比较每个节点的 data 域与给定的元素 e。如果找到相等的节点，则返回该节点的序号（从 1 开始计数）；如果遍历完单链表都未找到，则返回 0。

  10. ListInsert（在单链表中第 i 个位置插入元素 e）

  • 从单链表的头节点开始遍历单链表，找到第 i - 1 个节点。如果找不到或者 i 不合法，则返回 false。
  • 如果找到了第 i - 1 个节点，创建一个新的节点 s，将其 data 域赋值为 e，并将其 next 指针指向第 i 个节点，然后将第 i - 1 个节点的 next 指针指向新节点 s，实现插入操作。

11.ListDelete（从单链表中删除第 i 个元素）

  • 从单链表的头节点开始遍历单链表，找到第 i - 1 个节点。如果找不到或者 i 不合法，则返回 false。
  • 如果找到了第 i - 1 个节点，将其下一个节点 q 保存下来。如果 q 为 NULL，表示不存在第 i 个节点，返回 false。
  • 如果 q 不为 NULL，将 q 节点的 data 域的值赋给传入的引用参数 e，然后将第 i - 1 个节点的 next 指针指向 q 的下一个节点，释放 q 节点的内存空间，实现删除操作。
筱姌
关注
专栏目录
数据结构实验一线性表的基本操作.docx
03-28
数据结构实验一线性表的基本操作 一、线性表的概念和类型 线性表是一种基本的数据结构，它是一种由零个或多个元素组成的有限序列，每个元素都是数据类型的实例。线性表可以分为两种类型：顺序存储结构和链式存储...
C++数据结构实验一：线性表的应用
03-29
1．熟练掌握线性表的基本运算。 2．掌握顺序表和单链表...4. 掌握线性表的逻辑结构特点、顺序存储结构、链式存储结构、顺序表的结构体类型定义、单链表的结构体类型定义、在两种存储结构上的各种基本操作的实现算法。
数据结构实验二：线性表之操作
2301_80249313的博客
09-26 928
后面将定义的若干操作与当前位置有关，例如：在当前位置结点之前插入结点，在当前位置结点之后插入结点，等等。·删除线性表位置i处的数据元素： 删除线性表的i号数据元素。·删除线性表中第一个值为x的数据元素： 删除第一个值为x的数据元素，返回该数据元素的编号。·设置线性表当前位置的下一位置为当前位置： 设置成功，则返回true，否则返回false（线性表为空，或当前位置为表尾）。·删除线性表当前位置后面的那个数据元素结点： 若删除失败（为空表，或当前位置是表尾），则返回false，否则返回true。
C++数据结构实验一：线性表
m0_73700621的博客
06-14 1184
C++数据结构实验：树和二叉树。有一个学生成绩文本文件xyz4.in，第一行为整数n，接下来为n行学生基本信息，包括学号、姓名和班号，接下来为整数m，然后为m行课程信息，包括课程编号和课程名，再接下来为整数k，然后为k行学生成绩，包括学号、课程编号和分数。编写一个程序按班号递增排序输出所有学生的成绩，相同班号按学号递增排序，同一个学生按课程编号递增排序，相邻的班号和学生信息不重复输出。
数据结构 实验报告一 线性表
qq_72560062的博客
03-11 4586
数据结构实验一线性表
数据结构实验二 线性表的链式存储结构
shemzukijata的博客
12-16 589
1.熟练掌握单向链表和单项循环链表基本操作的C语言实现。2.掌握链表的应用，逐步培养解决实际问题的能力。3.能够从时间和空间复杂度的角度综合比较线性表两种存储结构的不同特点及适用场景。4.培养学生程序设计能力，要求编写的程序结构清楚和正确易读，符合软件工程的规范。4.培养学生利用链表解决实际问题的能力。
数据结构实验报告：线性表顺序存储
2401_86055263的博客
06-29 417
1．编写顺序表的插入和删除算法 2. 编写将两个顺序表合并的算法
数据结构实验报告——线性表
我们都有光明的未来
12-14 3446
顺序表 #include<bits/stdc++.h> using namespace std; const int LISTSIZE=10;///顺序存储的最大元素数量 const int maxn=100;///每次分配的元素个数 #define ERROR -1 #define OK 1 int n,m; typedef int ElemType; struct List { ElemType* elem; int len,listsize; }; void output(
数据结构实验二： 线性表之应用
2301_80249313的博客
10-03 954
本关任务要求针对顺序存储的线性表完成三个操作函数，分别实现线性表中数据的插入、删除与查找等功能。线性表是最基本、最简单、也是最常用的一种数据结构。线性表结构中，数据元素之间通过一对一首尾相接的方式连接起来。具体实现时，线性表可以采用不同的存储策略。下面给出了一种基于顺序存储的线性表实现方案：该方案将线性表存储在一片连续空间里，并通过data、len和max三个属性元素。组织成为一个结构：data: 给出线性表存储空间的起始地址max: 指明线性表存储空间最多可存储的数据元素个数。
【数据结构】实验：线性表的操作及应用
m0_73970214的博客
08-08 1318
定义一个包含学生信息（学号，姓名，5科成绩（C语言 计算机基础 高等数学 大学英语 马克思原理），总分）的顺序表和链表，分别用顺序表或单链表实现如下功能：（两者都实现的同学可加分） (1) 整体建表，根据指定学生个数，逐个输入学生信息；（学号不能重复，总分计算机自动计算） (2) 输出学生表信息； (3) 查找学生信息（可根据姓名或学号查找）； (4) 插入新学生信息（插入学生的学号不能和已有学生学号重复）； (5)删除给定学号的学生信息； (6) 学生信息表排序（可按任意给定的关键字排序）
数据结构之线性表之线性表顺序存储结构
m0_74018560的博客
12-10 780
数据结构之线性表部分之线性表存储结构
数据结构实验报告-线性表-两个有序线性表的归并算法
04-10
本次实验的主题是“数据结构实验报告-线性表-两个有序线性表的归并算法”。实验的主要目的是让学生掌握两个有序线性表的归并算法。具体来说，实验要求学生通过键盘输入数据来建立两个有序线性表，并最终将这两个有序...
数据结构实验报告2线性表的链式存储结构.pdf
09-30
数据结构实验报告2线性表的链式存储结构 本实验报告的主要内容是介绍线性表的链式存储结构，并通过编程实验来掌握线性表的逻辑结构和链式存储结构，以及单链表的基本算法。 一、线性表的概念 线性表是最基本的...
数据结构实验报告1线性表的顺序存储结构.doc
07-11
实验报告的主题是“数据结构实验报告1：线性表的顺序存储结构”，旨在通过实践让学生掌握线性表在顺序存储结构中的基本操作，包括创建、插入和删除等。实验使用了Visual C++作为开发环境，并涉及到了C++编程语言。 ...
【Java数据结构】二叉树
2401_83227065的博客
10-13 946
1.2.3.4.
408 10——42题
最新发布
2402_85676269的博客
10-14 628
设将n(n>1)个整数存放到一维数组R中。试设计一个在时间和空间两方面都尽可能高效的算法。将R中保存的序列循环左移p(0<p<n)个位置，即将R中的数据由 口X00X1...Xn-1口变换为口Xp口Xp+1...Xn-10X00X1...Xp-1口。要求:(1)给出算法的基本设计思想。(2)根据设计思想，采用C或C++或JAVA语言描述算法，关键之处给出注释，(3)说明你所设计算法的时间复杂度和空间复杂度。
数据结构：用双栈实现一个队列
AWSDN的博客
10-11 277
本文主要介绍如何用双栈实现一个队列
数据结构：使用双队列实现一个栈
AWSDN的博客
10-11 254
本文主要介绍如何用双队列实现一个栈
浙大数据结构：09-排序1 排序
qq_74924951的博客
10-11 312
多种排序算法总结
数据结构实验指导：线性表操作详解
"数据结构实验指导书，由计算机学院专业基础教研室于2004年3月编写，旨在帮助学生掌握数据结构中的线性表及其应用。实验内容涵盖顺序线性表和链式线性表的创建、插入和删除操作。实验通过C语言实现，强调了顺序存储...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

筱姌

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

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

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

打赏作者

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

抵扣说明：

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

余额充值