数据结构 链表 c++语言 详细代码

最新推荐文章于 2024-06-17 08:19:26 发布
最新推荐文章于 2024-06-17 08:19:26 发布
阅读量410 收藏
点赞数 2
文章标签： c++ 开发语言 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62512076/article/details/126839719
版权

# 顺序栈****

**$栈是操作受限的**线性表**，插入删除数据元素**只能在线性表的一端**进行$**

## 栈类的定义 c++版异常捕获优化

    #include<iostream>
    using namespace std;
    const int MAX_SIZE = 100;
    class Stack
    {
    private:
        char* data;             //线性表
        int size;
        int top;
    public:
        Stack();
        Stack(int s);                  //有参构造函数
        ~Stack();
        void push(char ch);             //入栈
        char pop();                     //出栈
        char getTop();                  //弹出栈顶
        bool isEmpty();
        bool isFull();
        class Empty {};
        class Full {};
    };
    Stack::Stack()
    {
        size = MAX_SIZE;
        top = -1;
        data = new char[MAX_SIZE];      //构造最大空间
    }
    Stack::Stack(int s)   //有参构造函数
    {
        size = s;
        top = -1;
        data = new char[size];
    }
    Stack::~Stack()       //析构函数
    {
        delete[]data;
    }
    void Stack::push(char ch)       //入栈
    {
        if (isFull())
        {
            throw Full();
        }
        else
        {
            data[++top] = ch;
        }
    }
    char Stack::pop()             //出栈
    {
        if (isEmpty())
        {
            throw Empty();
        }
        else
        {
            return data[top--];
        }
    }
    char Stack::getTop()         //弹出栈顶
    {
        if (!isEmpty())
        {
            return data[top];
        }
    }
    bool Stack::isEmpty()      //栈空
    {
        if (top == -1)
            return true;
        else
            return false;
    }
    bool Stack::isFull()       //栈满
    {
        if (top == size - 1)
            return true;
        else
            return false;
    }
    int main()
    {
        try {
            Stack s1;
    
        }
        catch (Stack::Full)          //异常内部类捕获
        {
            cout << "Full!" << endl;
        }
        catch (Stack::Empty)
        {
            cout << "Empty" << endl;
        }
        return 0;
    }

## 栈类的定义c语言版

    #include<stdio.h>
    #include<stdlib.h>
    #define MAX_SIZE 100
    typedef struct Stack    //结构体
    {
        char* data;
        int size;
        int top;
    };
    void initStack(Stack& s)   //初始化
    {
        s.data = (char*)malloc(sizeof(char) * MAX_SIZE);
        if(!s.data)
            exit(0);
        s.size = MAX_SIZE;
        s.top = -1;
    }
    void destroyStack(Stack& s)
    {
        free(s.data);    //内存回收
    }
    void push(Stack s, char ch)
    {
        if (!isFull(s))
        {
            s.data[++s.top] = ch;
        }
    }
    char pop(Stack s)    //出栈
    {
        if (!isEmpty(s))
        {
            return s.data[s.top--];
        }
    }
    char getTop(Stack s)    //获取栈顶元素
    {
       if (!isEmpty(s))
        {
            return s.data[s.top];
        }
    }
    bool isEmpty(Stack s)  //栈空
    {
        if (s.top == -1)
            return true;
        else
            return false;
    }
    bool isFull(Stack s)     //栈满
    {
        if (s.top == size-1)
            return true;
        else
            return false;
    }
    

## **顺序栈的应用 特殊字符的处理**

 

``源代码

    #include<string>
    #include<iostream>
    using namespace std;
    const int MAX_SIZE = 100;
    class Stack
    {
    private:
        char* data;             //线性表
        int size;
        int top;
    public:
        Stack();
        Stack(int s);                  //有参构造函数
        ~Stack();
        void push(char ch);             //入栈
        char pop();                     //出栈
        char getTop();                  //弹出栈顶
        bool isEmpty();
        bool isFull();
        void setNull();
        void reversedisplay();          //为了更好的正向输出栈
    };
    Stack::Stack()
    {
        size = MAX_SIZE;
        top = -1;
        data = new char[MAX_SIZE];      //构造最大空间
    }
    Stack::Stack(int s)   //有参构造函数
    {
        size = s;
        top = -1;
        data = new char[size];
    }
    Stack::~Stack()       //析构函数
    {
        delete[]data;
    }
    void Stack::push(char ch)       //入栈
    {
        if (!isFull())
        {
            data[++top] = ch;
        }
    }
    char Stack::pop()             //出栈
    {
        if (!isEmpty())
        {
            return data[top--];
        }
    
    }
    char Stack::getTop()         //弹出栈顶
    {
         if (!isEmpty())
        {
            return data[top];
        }
    }
    bool Stack::isEmpty()      //栈空
    {
        if (top == -1)
            return true;
        else
            return false;
    }
    bool Stack::isFull()       //栈满
    {
        if (top == size - 1)
            return true;
        else
            return false;
    }
    void Stack::setNull()
    {
        top = -1;
    }
    void Stack::reversedisplay()//展示
    {
        int len = top;
       char strx[100];
       for (int i = 0;i <= len;i++)
       {
          strx[len - i] = pop();
       }
       strx[len + 1] = '\0';
       if (top == -1)
           cout << "栈为空" << endl;
       else
           cout << strx;
    }
    int main()
    {
        char str=0;
        Stack s1;
        while (str!= '#')
        {
            str = getchar();
            switch (str) {
            case '<':
            {
                s1.pop();
                break;
            }
    
            case '@':
            {
                s1.setNull();
                break;
            }
    
            case   '\n':
            {
                s1.reversedisplay();
                break;
            }
    
            case  '#':
            {
                s1.reversedisplay();
                break;
            }
    
    
            default:
            {
                s1.push(str);
                break;
            }
    
            }
    
        } 
        return 0;
    }

## 回文字符串判断``

 

    上接stack类定义
    int main()
    {
        Stack s1;
        int len=0;
        char strx[100];
        cin >> strx;
        len = strlen(strx);
        for (int i = len / 2 - 1;i >= 0;i--)    //把前一半的字符从后到前压栈
        {
            s1.push(strx[i]);
        }
        bool flag = true;
        for(int i=len-1;i>len/2;i--)           //出栈的时候和字符串后一半从后往前捋一样，这样不用理会中间的那个
        {
            if (s1.pop() != strx[i])
            {
                flag = false;
                break;
            }
        }
        if (flag)
        {
            cout << "是回文字符串" << endl;
        }
        else
            cout<< "不是回文字符串" << endl;
        return 0;
    }

## 用类模板实现顺序栈

    #include<iostream>
    using namespace std;
    const int MAX_SIZE = 100;
    template <class T>
    class Stack
    {
    private:
        T* data;             //线性表
        int size;
        int top;
    public:
        Stack();
        Stack(int s);                  //有参构造函数
        ~Stack();
        void push(T ch);             //入栈
        T pop();                     //出栈
        T getTop();                  //弹出栈顶
        bool isEmpty();
        bool isFull();
        class Empty {};
        class Full {};
    };
    template <class T>
    Stack<T>::Stack()
    {
        size = MAX_SIZE;
        top = -1;
        data = new T[MAX_SIZE];      //构造最大空间
    }
    template <class T>
    Stack<T>::Stack(int s)   //有参构造函数
    {
        size = s;
        top = -1;
        data = new T[size];
    }
    template <class T>
    Stack<T>::~Stack()       //析构函数
    {
        delete[]data;
    }
    template <class T>
    void Stack<T>::push(T ch)       //入栈
    {
        if (isFull())
        {
            throw Full();
        }
        else
        {
            data[++top] = ch;
        }
    }
    template <class T>
    T Stack<T>::pop()             //出栈
    {
        if (isEmpty())
        {
            throw Empty();
        }
        else
        {
            return data[top--];
        }
    }
    template <class T>
    T Stack<T>::getTop()         //弹出栈顶
    {
        if (!isEmpty())
        {
            return data[top];
        }
    }
    template <class T>
    bool Stack<T>::isEmpty()      //栈空
    {
        if (top == -1)
            return true;
        else
            return false;
    }
    template <class T>
    bool Stack<T>::isFull()       //栈满
    {
        if (top == size - 1)
            return true;
        else
            return false;
    }
    int main()
    {
        try {
            Stack<int> s1;
              Stack<char> s2;
    
        }
        catch (Stack<int>::Full)          //不同异常内部类捕获，注意增加
        {
            cout << "Full!" << endl;
        }
        catch (Stack<char>::Empty)
        {
            cout << "Empty" << endl;
        }
        return 0;
    }

 

## 两栈共享存储空间

    #include<iostream>
    using namespace std;
    const int MAX_SIZE = 100;
    template <class T>
    class Stack
    {
    private:
        T* data;             //线性表
        int size;
        int top1,top2;
    public:
        Stack();
        Stack(int s);                  //有参构造函数
        ~Stack();
        void push(int n,T ch);             //入栈
        T pop(int n);                     //出栈
        T getTop(int n);                  //弹出栈顶
        bool isEmpty(int n);
        bool isFull(int n);
        class Empty {};                    //异常内部类
        class Full {};
        class numerror{};                   //数字输入异常类
    };
    template <class T>
    Stack<T>::Stack()
    {
        size = MAX_SIZE;
        top1 = -1;
        top2 = size;
        data = new T[MAX_SIZE];      //构造最大空间
    }
    template <class T>
    Stack<T>::Stack(int s)   //有参构造函数
    {
        size = s;
        top1 = -1;
        top2 = size;
        data = new T[size];
    }
    template <class T>
    Stack<T>::~Stack()       //析构函数
    {
        delete[]data;
    }
    template <class T>
    void Stack<T>::push(int n,T ch)       //入栈
    {
        if (isFull(n))
        {
            throw Stack<T>::Full();
        }
        else
        {
            if (n == 1)
                data[++top1] = ch;
            else if (n == 2)
                data[--top2] = ch;
            else
                throw  Stack<T>::numerror();
        }
    }
    template <class T>
    T Stack<T>::pop(int n)             //出栈
    {
        if (isEmpty(n))
        {
            throw Stack<T>::Empty();
        }
        else
        {
            if (n == 1)
                return data[top1--];
            else if (n == 2)
                return data[top2++];
            else
                throw  Stack<T>::numerror();
        }
    }
    template <class T>
    T Stack<T>::getTop(int n)         //弹出栈顶
    {
        if (!isEmpty(n))
        {
            if (n == 1)
                return data[top1];
            else if (n == 2)
                return data[top2];
            else
                throw  Stack<T>::numerror();
        }
    }
    template <class T>
    bool Stack<T>::isEmpty(int n)      //栈空
    {
        if (n == 1)
        {
            if (top1 == -1)
                return true;
            else
                return false;
        }
        else if(n==2)
        {
            if (top2 == size)
                return  true;
            else
                return false;
        }
    }
    template <class T>
    bool Stack<T>::isFull(int n)       //栈满
    {
        if (top1 ==top2 - 1)
            return true;
        else
            return false;
    }
    int main()
    {
        try {
            Stack<int> s1;
              Stack<char> s2;
              s1.push(2,2);
              s1.push(2, 3);
              cout << s1.pop(2) << endl;
              cout<<s1.pop(2);
    
        }
        catch (Stack<int>::Full)          //不同异常内部类捕获  可视情况添加
        {
            cout << "Full!" << endl;
        }
        catch (Stack<char>::Empty)
        {
            cout << "Empty" << endl;
        }
        catch (Stack<int>::numerror)
        {
            cout << "number erroe!!" << endl;
        }
        return 0;
    }

# 链栈

**<u><mark>链头作为栈顶，不需要设置头节点</u>**</mark>

    #include<iostream>
    using namespace std;
    template<class T>            //结构体模板
    struct node
    {
        T data;
        struct node* next;
    };
    template<class T>                //链栈模板类
    class LinkStack
    {
    private:
        struct node<T>* top;
    public:
        LinkStack();
        ~LinkStack();
        void push(T x);
        T pop();
        T getTop();
        bool isEmpty();  //不需要判满，因为不会满
    
    };
    
    template<class T>                    //构造函数
    LinkStack<T>::LinkStack()
    {
        top = NULL;
    }
    
    template<class T>                    //析构函数  清除链表
    LinkStack<T>::~LinkStack()
    {
        struct node<T>* p=NULL;
        while (top)
        {
            p = top->next;
            delete top;
            top = p;
        }
    }
    
    template<class T>                    //获取栈顶元素
    T  LinkStack<T>::getTop()
    {
        if (top == NULL)
            return -1;
        else
        {
            T x = top->data;
            return x;
        }
    
    }
    template<class T>                //压栈
    void LinkStack<T>::push(T x)
    {
        struct node<T>* s = new struct node<T>;
        s->data = x;
        s->next = top;
        top = s;
    }
    
    template<class T>                //出栈
    T LinkStack<T>::pop()
    {
        if (top == NULL)
        {
            return -1;  //抛出异常
        }
        T x = top->data;
        struct node<T>* p = top;
        top = top->next;
        delete p;
        return x;
    }
    template<class T>
    bool LinkStack<T>::isEmpty()
    {
        if (top == NULL)
            return true;
        else
            return false;
    }
    int main()
    {
        LinkStack<int> s1;
        s1.push(2);
        s1.push(3);
        cout << s1.pop()<<endl;
        cout << s1.pop()<<endl;
    
        return 0;
    }

大肥羊学校懒羊羊
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
【数据结构】顺序栈实现字符串处理（作业2）
l634007854的博客
10-30 611
https://www.cnblogs.com/gonghr/p/14508203.html#!comments
C++数据结构之链表
yao____yao的专栏
04-11 334
C++数据结构------链表       typedef int T;       struct Node{       T data;        Node* next;        Node(const T& d=T()):data(d),next(NULL){} }; class List{           Node* head; }; 经典insert&&
数据结构实验(含源码)
02-11
数据结构》实验题目 实验一 学生成绩管理（链表）  实验目的：熟练掌握单链表操作的基本算法实现。  实现功能：以带表头结点的单链表为存储结构，实现如下学生成绩管理的设计要求。  实验机时：6  设计要求： (1)定义学生成绩链表结点结构类型，以xscjList和*XscjLink命名，数据域：学号NO、姓名Name、手机号MTel、邮箱地址Email、籍贯 BornAddr、A分成绩AScore、B分成绩BScore，指针域：*next； (2)实现创建学生成绩链表函数void Build(XscjLink &T)，输入学号、姓名、手机号、邮箱地址、籍贯、A分成绩、B分成绩，建议用文件操作来输入数据； (3)实现函数void Update(XscjLink T, char *Name, float *ScoreA)，将姓名为Name的学生的A分成绩改为ScoreA； (4)实现输出学生成绩信息void OutPut(XscjLink T)，输出所有学生的学号、姓名、手机号、邮箱地址、籍贯、A分成绩、B分成绩； (5) 实现函数void Insert(XscjLink T, char *Name, char *No)，插入学号为NO，姓名为Name学生信息,将链表中学号≤NO的结点放到该结点的前面，将学号>NO的结点放到该结点后面； (6)实现函数void Sort(XscjLink T)，将该学生按照B分成绩进行非递减排序； (7)实现函数void Merge(XscjLink &T1;, XscjLink &T2;)，将两个按B分成绩非递减排序的学生成绩单合并为一个按B分成绩非递增排序的通讯录，B分成绩相同且学号相同的成绩记录在结果中只保留一个；要求算法的时间复杂度不超过两个链表的长度之和O(m+n)； (8)实现函数int Count(XscjLink T)；统计籍贯是“广州”的学生人数； (9)实现函数void MoveK(XscjLink T, int k)，将学生成绩链表中倒数第k个结点之后的所有结点移到头结点后面（保持结点间的先后顺序），注意：严禁采用先计算链表长度n再减k（即n-k）的方法；要求算法的时间复杂度不超过个链表的长度O(n)； (10)实现函数void ReverseN(XscjLink T)，将学生成绩链表的正中间位置结点之后的全部结点倒置，注意：严禁采用先计算链表长度n再除以2（即n/2）的方法；要求算法的时间复杂度不超过个链表的长度O(n)； (11)主控函数main()调用以上函数，分别输出（2）、（3）、（5）、（6）、（7）、（8）、（9）（10）处理后的链表内容、输出籍贯是“广州”的学生人数。 可能用到的函数： 从文件中读取学生成绩数据：fscanf(文件指针,"%s %s %s %s %s %f %f", p->NO, p->Name, p->Mtel, p->Email, p-> BornAddr, p->AScore, p->BScore); 输出学生成绩数据：printf("%s %s %s %s %s %f %f", p->NO, p->Name, p->Mtel, p->Email, , p-> BornAddr, p->AScore, p->BScore); 字符串赋值函数：char * strcpy(char *, const char *); 字符串比较函数：int strcmp(const char *, const char *) #include #include #include //定义学生成绩链表结点结构 typedef struct XscjNode { char NO[10]; //学号 char Name[16]; //姓名 char MTel[11]; //手机号 char EMail[16]; //邮箱地址 char BornAddr[20]; //籍贯(值域："北京"、"上海"、"大连"等等，只写城市名称) float AScore; // A分成绩 float BScore; //B分成绩 struct XscjNode *next; //指针域 }XscjList, *XscjLink; 实验二 Huffman编码（二叉树）  实验目的：熟练掌握二叉树应用（Huffman编码）的基本算法实现。  实现功能：对输入的一串电文字符实现Huffman编码，再对Huffman编码生成的代码串进行译码，输出电文字符串。实现功能如下： • Huffman树的建立 • Huffman编码的生成 • 编码文件的译码  实验机时：10  设计思路： 数据结构： #define n 100 //叶子结点数 #define m 2*n-1 // Huffman树中结点总数 typedef struct { char data; 字符 int weight; //权值 int lchild , rchild , parent; //左右孩子及双亲指针 }HTNode; //树中结点类型 typedef HTNode HuffmanTree[m+1]; //0号单元不用 主要实现函数：  统计字符串中字符的种类以及各类字符的个数的函数  构造Huffman树的函数  Huffman编码的函数  建立正文的编码文件的函数  代码文件的译码函数  主函数 实验三 各种排序方法的比较  实验目的：熟练掌握内部排序算法的实现。  实现功能：编制一个演示内部排序算法比较的程序。要求通过编写程序实现起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序等常用的内部排序算法，并通过样本数据比较各个算法的时空特性  实验机时：4
顺序栈和链栈（简单例题_1C++）
快乐不能半途而废的博客
03-01 1085
【题目要求】输入若干串字符，每次遇到换行符’\n’时，则输出本行当前处理结果。输入时以“#”字符作为结束符，当遇到这个符号后，意味着字符串输入结束。（在输入过程中如果输入“<”，则表示回退一格；在输入过程中如果包含了“@”，则表示回退到本行行首。） ...
学生成绩管理（链表）c++
where_are_u的博客
01-29 3855
设计一个“学生成绩管理系统”，主要实现学生信息的录入、添加、修改、删除、排序和查看以及对存档等功能。
用一个栈实现另一个栈的排序
weixin_34029949的博客
11-06 76
importjava.util.Objects; importjava.util.Stack; classSolution{ privateStack<Integer>secondStack=newStack<>(); publicvoidsort(Stack<Integer>stack){...
数据结构之链表（C++语言描述）
一只小汤米
09-26 1211
链表，是最基础的数据结构之一，其存储空间的不连续性以及便捷的添加节点和删除节点的优点让其应用颇广。今天主要谈一谈链表的一些基础也是核心算法，即链表的增删改查以及链表反转（reverse）。
数据结构链表：单链表的代码实现
03-20
本文通过数据结构教程的方法利用C++语言写了单链表的各项功能 功能包括 1.链表的初始化 2.链表的查找和判断是否为空表 3.插入 4.取值 5.插入（尾插法） 6.链表的输出 7.//删除指定元素 8.//链表的释放 其中有着详细...
二叉链表的应用c++代码_二叉链表c++代码_
09-30
数据结构课程中，二叉链表的应用，使用c++语言编程实现
五邑大学C++简单数据结构代码.zip
06-30
简单的C++语言实现数据结构，内含线性表，链表，栈，队列，二叉树，哈夫曼树以及图的简单实现，简单易懂
数据结构C++链表
03-04
基于C++的数据结构单链表，带主程序可运行，使用头文件可直接编程。
010 数据结构逆向—链表1
08-03
在逆向工程中，数据结构的理解至关重要，尤其是链表这种动态数据结构。本文将深入探讨如何从给定的代码片段中解析链表结构，并提供相关的编程实现和逆向分析技巧。 链表是一种线性数据结构，它由一系列节点组成，每...
数据结构 第一章 前置知识 链表
12-16
链表的实现可以使用C语言或C++语言。下面是一个使用C语言实现链表的示例代码： ```c #include #include typedef struct List { int data; struct List* pNext; } LT, *PLT; PLT Create(PLT pHead) { pHead = ...
数据结构-链表（含全部实现代码）
qq_45967533的博客
03-12 7203
本篇的内容是对链表的一个介绍，并且会使用C语言实现链表的几个主要接口。 目录链表的概念与结构 链表的概念与结构 概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。 一个链表由n个节点组成，每一个节点都是一个结构体，这个结构体里的一个成员是该节点存储的数据，另一个成员是指向下一个节点的指针。 其结构如下 上图只是一种结构的链表，并不是所有的链表都是这样的结构，在实际中链表的结构非常多样，有以下几种情况：是否带头，单向还是双向，是否循环。共23=8种
数据结构—单链表的操作与实现—c++代码（含全部代码）
Initial_Mind的博客
01-21 6096
单链表的操作与实现
学生信息管理系统c++(单链表增删改查)
小的博客
06-16 897
c++使用单链表实现增删改查的学生信息管理系统
c++链表（学生信息）
qq_61822522的博客
12-13 5077
1.根据学生信息储存结构，定义结点类型如下： typedef struct StuNode { int snum; char sname[20]; float score; struct Student *...
C的I/O操作
最新发布
weidl001的博客
06-17 734
输入输出（I/O）操作在C语言编程中占据重要地位，包括文件与目录操作、字符流与字节流处理，以及序列化与反序列化。通过深入理解和掌握这些I/O操作，程序员可以实现与外部环境的高效数据交互，为各种应用场景提供稳定可靠的解决方案。无论是文本文件的读写、二进制数据的处理，还是复杂数据结构的序列化和反序列化，这些I/O操作的掌握都对编写高效、健壮的C程序至关重要。
数据结构与算法单项链表代码C++
10-17
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。单向链表的实现可以使用C++语言来完成。以下是一个简单的单向链表的代码示例： ```c++ #include <iostream> using namespace std; // 定义链表节点结构体 struct ListNode { int val; ListNode* next; ListNode(int x) : val(x), next(NULL) {} }; // 定义链表类 class LinkedList { public: LinkedList() { head = NULL; } // 在链表头部插入节点 void insertAtHead(int val) { ListNode* newNode = new ListNode(val); newNode->next = head; head = newNode; } // 在链表尾部插入节点 void insertAtTail(int val) { ListNode* newNode = new ListNode(val); if (head == NULL) { head = newNode; } else { ListNode* cur = head; while (cur->next != NULL) { cur = cur->next; } cur->next = newNode; } } // 删除链表中第一个值为val的节点 void deleteNode(int val) { if (head == NULL) { return; } if (head->val == val) { ListNode* temp = head; head = head->next; delete temp; return; } ListNode* cur = head; while (cur->next != NULL && cur->next->val != val) { cur = cur->next; } if (cur->next != NULL) { ListNode* temp = cur->next; cur->next = cur->next->next; delete temp; } } // 遍历链表并输出每个节点的值 void printList() { ListNode* cur = head; while (cur != NULL) { cout << cur->val << " "; cur = cur->next; } cout << endl; } private: ListNode* head; }; // 测试代码 int main() { LinkedList list; list.insertAtHead(1); list.insertAtHead(2); list.insertAtTail(3); list.insertAtTail(4); list.printList(); list.deleteNode(2); list.printList(); return 0; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

大肥羊学校懒羊羊

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

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

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

打赏作者

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

抵扣说明：

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

余额充值