数据结构—链表的应用（详细过程）

已于 2024-06-02 19:55:55 修改
阅读量783 收藏 13
点赞数 23
文章标签： 数据结构 链表
于 2024-05-28 00:28:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74889808/article/details/139123282
版权

前期提要： 

        在了解了顺序表和线性表的特性和应用之后，我们发现在插入元素的时候线性表所做的操作非常麻烦，插入中间元素时要把后面的所有的元素都往后挪，而且顺序表在插入元素的时候还要考虑表是否需要扩容。

        链表就完美规避了这些问题，只需要断开元素之间的联系，再将插入元素与原链表元素重新建立联系即可，不需要对表进行扩容。

概念以及结构： 

概念：

        链表是一种物理结构上非连续的存储结构（存储内容在内存中并不一定连续——存储地址）

        数据元素的逻辑顺序是通过链表中的引用链接次序实现的。

结构分类：

        链表中有：单向、双向、带头节点、不带头结点、循环、不循环，这总共六种特点，由特点进行排列组合形成八种链表，其中linkedlist底层的链表就是 双向  不带头 非循环 类型链表

        着重了解不带头、非循环的链表，是最常用到的链表类型 。

节点：

        链表的节点由两部分组成：存放元素的数值域，存放下一个节点引用的next域

链表的链接方式：

不带头的链表：

带头的链表：

二者的区别：头结点的引用不一致 ，带头链表的头结点作为引用是固定的，不带头链表的头结点一旦换了结点，那头结点的引用也就跟着发生了改变（头结点的地址）

单向与双向：

单向链表：

        单向链表的结点只能往下走，无法通过引用访问上一个节点

双向链表：

        区别于单向链表，双向链表的结点引用既可以往后走，也可以往前走

        通过引用当前节点的前驱prev，来访问当前节点的上一个节点

 

循环与不循环： 

代码实现：

    链表是引用对象，用一个内部类来实现节点类，节点类中包含了节点的各种成员变量（如果另外新建一个.java文件将创建结点类类，如果不用内部类的话则需要进行继承）

   static class ListNode{
        public int val;                 //节点值
        public ListNode next;           //节点的next域，后继结点
        public ListNode prev;           //节点的prev域，前驱结点

        //对节点初始化
        public ListNode(int val)
        {
            this.val = val;
        }

    }

链表的打印：

    public void display() {
            ListNode cur = head;                //cur作为引用指向，当cur为空时说明已经走到链表尽头
            while (cur!=null)
            {
                System.out.print(cur.val+" ");
                cur = cur.next;
            }
        System.out.println();
    }

增：

头插法：

        头插法就是把节点一个个串一起，先插入的头结点会变成后插入节点的下一个节点，也就是头结点因为节点的插入在不断地变化。

插入节点的实现方法：

        不断变换头结点，让先插入的节点变成后插入节点的后继结点即可

 public void addfirst(int data) {
        ListNode node = new ListNode(data);
        node.next = this.head;                
        this.head = node;

    }

 创建节点，然后创建表格进行插入操作

    public static void main(String[] args) {
        ListNode node1 = new ListNode(12);
        ListNode node2 = new ListNode(23);
        ListNode node3 = new ListNode(34);
        ListNode node4 = new ListNode(56);

        MySinglelist list = new MySinglelist();
        list.addfirst(node1.val);
        list.addfirst(node2.val);
        list.addfirst(node3.val);
        list.addfirst(node4.val);
        list.display();

    }

通过结果可以发现先插入的节点被挪到了后面 

尾插法：

        尾插法就是将第一个插入的元素作为头结点，在头结点不变的情况下不断地往后面插入节点。

        在插入一个元素作为头结点的同时，链表的尾节点和头结点在同一起跑线上，后续有元素插入都是插入到尾节点后面，所以每次插入元素的操作都是修改将插入的节点修改为尾节点的后继结点

    public void addlast(int data) {
        ListNode node = new ListNode(data);
        if(head == null)                    //先判断链表是否为空，如果为空那就将插入的节点作为头结点
        {
            head = node;
            last = node;
        }
        else {
            last.next = node;               //往尾节点后插入元素
            last  = last.next;
        }
    }

 创建节点，然后建表进行插入操作

 public static void main(String[] args) {
        ListNode node1 = new ListNode(12);
        ListNode node2 = new ListNode(23);
        ListNode node3 = new ListNode(34);
        ListNode node4 = new ListNode(56);
        ListNode node5 = new ListNode(67);

        MySinglelist list = new MySinglelist();
        list.addlast(node1.val);
        list.addlast(node2.val);
        list.addlast(node3.val);
        list.addlast(node4.val);
        list.addlast(node5.val);
        list.display();
    }

结果;

 中间节点插入法： 

       在构思实现方法时，我们要有以下考虑：

1、实现方法中的返回参数类型、形参都有哪些？

2、既然是中间节点，说明不能插入到头结点前面和尾节点后面，插入的位置（也就是下标）要合理

3、插入的时候链表为空要怎么办？

4、插入的位置位于链表的哪个地方？怎么样插入才更加的快速？

解决问题1、2、3：

        因为实现方法只是对链表进行操作，并不需要有返回值，所以返回类型为void，形参则要有插入的结点值和插入的位置index

 public void addmid(int data,int index)

        很简单，既然插入的结点不能作为头结点和尾节点，那么只要是下标 index≤0 或 index ≥ length 就是属于下标越界。

        若链表为空，那么插入的结点就是头结点，也是尾节点

 ListNode node = new ListNode(data);
        int mid = size()/2;
        int length = size();
        if( index >= length || index <= 0)                //下标判定
        {
            System.out.println("下标越界！");
            return;
        }
         if(size()==0)                                   //若链表为空
        {
            head = node;
            last = head;
        }

解决问题4：

        我们插入中间节点node，只需要将（index-1）位置的后继结点改成node，然后将node的后继结点指向index位置的节点，这样就建立了节点之间的联系.

        而在效率问题上，我们可以找到链表的中间位置mid，然后判断插入节点node在链表的前半段还是后半段。

        index在链表前半段：

        建立节点联系需要知道中间节点node的前驱结点和后继结点，而这就要遍历链表。

        这里我们用需要两个指向分别记录node的前驱和后继结点，记录前驱节点的指向fast遍历速度要慢于记录后继结点slow的指向，由于是在链表中间插入，所以fast的起始位置是在第二个节点，而slow则是从头结点开始，这样fast指向往下走始终比slow快一步。   当fast走到index位置，便不再往下走，这时候将插入节点node改为slow的后继结点，node的后继结点就是fast指向的结点，这样就能建立插入节点与前驱和后继结点的联系

 

代码块：

 if( index >= mid )                    //若下标在链表的前半段
            {
                ListNode fast = head.next;
                ListNode slow = head;
                while( index-1 > 0 )
                {
                    fast = fast.next;
                    slow = slow.next;
                    fast.prev = slow.next;
                    index--;
                }
                slow.next = node;
                node.next = fast;

            }

         index位置刚好是尾节点在的位置：

        这种情况分为两种：一种就是链表长度为2，头结点和尾节点不是同一个，另一种就是链表长度为1，头结点和尾节点是同一个

        不过节点建立联系却很简单，这种情况下头结点就是slow指向，而尾节点就是fast指向，按照上述建立节点联系的思路即可

代码块：

else if ( mid == 0 || mid == 1)                   //链表长度是1
            {
                last.next = node;
                last = last.next;
            }

        index位置在链表的后半段：

        与index在链表前半段的思路差不多，反其道而行，fast指向在尾节点的前一个节点位置，每次往前遍历节点都是fast先往前走，然后slow指向再往前走

        由于是要将节点node插入到index位置，所以在fast要走到index位置的前一个节点处，slow指向会走到index位置

 

 代码块：

 else                                                     //若下标在链表的后半段
            {
                ListNode fast = last.prev;
                ListNode slow = last;
                int num = length-index;
               while( num >0)
                {
                    fast = fast.prev;
                    slow.prev = fast.next;
                    num--;
                }
                fast.next = node;
                node.next = slow.prev;
            }

删：

        删除节点就是要断开节点间的联系，删除节点分别需要三个引用：一个负责记录删除index下标节点的前驱节点slow，一个负责记录index下标节点的后继结点fast，一个负责判断是否到达index位置cur

        实现删除指定下标节点，有几点需要考虑：

        1、指定下标的合法性       

        2、头结点和尾节点是比较特殊的删除（也是最简单的删除)      

        3、如何断开节点间的联系

解决问题1：

由于下标是从0开始，那index的合法区间就是[ 0，length-1)，在这个区间之外的下标都按越界处理

解决问题2和3：

        如果删除的是头结点，只需要将头结点的后继结点改为新的头结点即可。

        如果删除的是尾节点，那么就得分为两种情况：链表长度为2和长度大于2。如果链表长度等于2，那么只需要将头结点的后继结点改为null，然后把尾节点的引用改为头结点即可。如果大于2，那就得考虑三个引用的初始位置：跑的最慢的引用slow从起点开始，然后记录index位置的引用cur从头结点的下一个节点开始，跑的最快的引用fast在cur前面一步。

        用引用cur所在的结点对应的下标len与index位置作差，计算三个引用要遍历的节点个数，当index-len=0，说明cur已经遍历到了要删除的结点

这时候将slow引用的后继结点改为fast即可完成删除操作。

 完整代码块：

public void remove(int index) {
        int length = size();
        if(index >= length || index < 0 )
        {
            System.out.println("下标越界！");
        }
        else {
            if(index==0)                    //删除的是头结点
            {
                ListNode cur = head.next;
                head = head.next;
            }
            else{
                if(length == 2)   //删除的是尾节点且链表长度为2
                {
                    head.next = null;
                    last = head;
                }
                else {
                    ListNode cur = head.next;
                    ListNode slow = head;
                    ListNode fast = cur.next;
                    int len =1;
                    while (index-len!= 0) {
                            fast = fast.next;
                            slow = slow.next;
                            cur = cur.next;
                            len++;
                    }
                    slow.next = fast;
                }
            }
        }
    }

改：

        在明白了插入节点的思路之后，修改指定下标节点元素就是在用三个引用遍历到index位置所在的结点，然后将slow引用的后继结点改为要更改的结点node，再将node的后继结点改为fast即可。（当然，要记得进行下标合法性判断） 

看到这直接上代码块，思路与删的无异：

public void replace(int data, int index) {
        ListNode node = new ListNode(data);
        int length = size();
        if(index>=length || index<0){
            System.out.println("下标越界！");
        }
        else {
            ListNode cur = head.next;
            ListNode slow = head;
            ListNode fast = cur.next;
            int len =1;
            while (index-len!= 0) {
                fast = fast.next;
                slow = slow.next;
                cur = cur.next;
                len++;
            }
            slow.next = node;
            node.next = fast;
        }

    }

查： 

        查找有两种：用下标找节点，找链表中是否有该节点。这两种都至少简单的遍历链表，然后将结果返回。直接上代码：

    @Override
    public boolean search(int key) {
        ListNode cur = head;
        while(cur!=null)
        {
              if(cur.val==key)
              {
                  return true;
              }
              cur = cur.next;
        }
        return false;
    }
    //查找index位置所在的结点
    @Override
    public void find(int index) {
       int length = size();
       if(index>=length || index<0)
       {
           System.out.println("下标越界！");
       }
       else {
           ListNode cur = head;
            while(index !=0)
            {
                cur = cur.next;
                index--;
            }
           System.out.println("index位置节点的值是： "+cur.val);
       }
    }

最后把完整的代码奉上：

public class MySinglelist implements MyList {
    public ListNode head;
    public ListNode last;

    //内部类创建链表
    static class ListNode{
        public int val;                 //节点值
        public ListNode next;           //节点的next域
        public ListNode prev;           //节点的next域

        //对节点初始化
        public ListNode(int val)
        {
            this.val = val;
        }
    }
    //打印链表
    @Override
    public void display() {
            ListNode cur = head;
            while (cur!=null)
            {
                System.out.print(cur.val+" ");
                cur = cur.next;
            }
        System.out.println();
    }
    //头插法
    @Override
    public void addfirst(int data) {
        ListNode node = new ListNode(data);
        node.next = this.head;
        this.head = node;

    }

    @Override
    public void addmid(int data,int index) {
        ListNode node = new ListNode(data);
        int mid = size()/2;
        int length = size();
        if( index >= length || index <= 0)                //下标判定
        {
            System.out.println("下标越界！");
            return;
        }
        if(size()==0)                                   //若链表为空
        {
            head = node;
            last = head;
        }
        else {
            if( index >= mid )                    //若下标在链表的前半段
            {
                ListNode fast = head.next;
                ListNode slow = head;
                while( index-1 > 0 )
                {
                    fast = fast.next;
                    slow = slow.next;
                    fast.prev = slow.next;
                    index--;
                }
                slow.next = node;
                node.next = fast;

            }
            else if ( index == length || mid == 0)                   //若下标刚好与目前的链表长度相等或者下标是1
            {
                last.next = node;
                last = last.next;
            }
            else                                                     //若下标在链表的后半段
            {
                ListNode fast = last.prev;
                ListNode slow = last;
                int num = length-index;
               while( num >0)
                {
                    fast = fast.prev;
                    slow.prev = fast.next;
                    num--;
                }
                fast.next = node;
                node.next = slow.prev;
            }
        }
    }

    //尾插法
    @Override
    public void addlast(int data) {
        ListNode node = new ListNode(data);
        if(head == null)                    //先判断链表是否为空，如果为空那就将插入的节点作为头结点
        {
            head = node;
            last = node;
        }
        else {
            last.next = node;
            last  = last.next;
        }
    }
    //返回链表长度
    @Override
    public int size() {
        ListNode cur = head;
        int size = 0;
        while(cur!=null)
        {
            cur = cur.next;
            size++;
        }
        return size;
    }


    //删除指定节点元素
    @Override
    public void remove(int index) {
        int length = size();
        if(index >= length || index < 0 )
        {
            System.out.println("下标越界！");
        }
        else {
            if(index==0)                    //删除的是头结点
            {
                ListNode cur = head.next;
                head = head.next;
            }
            else{
                if(length == 2)   //删除的是尾节点且链表长度为2
                {
                    head.next = null;
                    last = head;
                }
                else {
                    ListNode cur = head.next;
                    ListNode slow = head;
                    ListNode fast = cur.next;
                    int len =1;
                    while (index-len!= 0) {
                            fast = fast.next;
                            slow = slow.next;
                            cur = cur.next;
                            len++;
                    }
                    slow.next = fast;
                }
            }
        }
    }
    //改变指定节点元素
    @Override
    public void replace(int data, int index) {
        ListNode node = new ListNode(data);
        int length = size();
        if(index>=length || index<0){
            System.out.println("下标越界！");
        }
        else {
            ListNode cur = head.next;
            ListNode slow = head;
            ListNode fast = cur.next;
            int len =1;
            while (index-len!= 0) {
                fast = fast.next;
                slow = slow.next;
                cur = cur.next;
                len++;
            }
            slow.next = node;
            node.next = fast;
        }

    }

    //查找链表是否存在对应的节点元素
    @Override
    public boolean search(int key) {
        ListNode cur = head;
        while(cur!=null)
        {
              if(cur.val==key)
              {
                  return true;
              }
              cur = cur.next;
        }
        return false;
    }
    //查找index位置所在的结点
    @Override
    public void find(int index) {
       int length = size();
       if(index>=length || index<0)
       {
           System.out.println("下标越界！");
       }
       else {
           ListNode cur = head;
            while(index !=0)
            {
                cur = cur.next;
                index--;
            }
           System.out.println("index位置节点的值是： "+cur.val);
       }
    }

    public static void main(String[] args) {
        ListNode node1 = new ListNode(12);      // 0
        ListNode node2 = new ListNode(34);      // 1
        ListNode node3 = new ListNode(45);      // 2
        ListNode node4 = new ListNode(56);      // 3
        ListNode node5 = new ListNode(67);      // 4

        ListNode node6 = new ListNode(23);

        MySinglelist list = new MySinglelist();
        list.addlast(node1.val);
        list.addlast(node2.val);
        list.addlast(node3.val);
        list.addlast(node4.val);
        list.addlast(node5.val);

       /* System.out.println(list.search(67));*/   // 查
        /*list.find(2);*/

     /*   list.remove(3);                          //删
        list.display();*/

        /*list.replace(node6.val,3);               //改
        list.display();*/

        /*  list.addmid(node6.val,2);              //中间插入节点
        list.display();*/
    }
}

因为我本人使用一个接口来实现链表的所有功能，所以主类里的所有方法都是经过重写的方法，在此附上接口的代码（主类中用alt+insert快捷键一键添加重写方法，详情跳转接口博客：http://t.csdnimg.cn/pI0uu）

public interface MyList {
    void addfirst(int data);
    void addlast(int data);
    void addmid(int data,int index);
    void display();
    void remove(int index);
    void replace(int data,int index);
    boolean search(int key);
    void find(int index);
    int size();
}

看到最后给个三连吧！！！

还听珊瑚海吗
关注
  • 23
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构：链表、栈
m0_62021646的博客
12-31 2039
1. 链表 1.1 什么是链表 链表是数据结构之一，其中的数据呈线性排列。 在链表中，数据的添加和删除都较为方便，访问比较耗费时间。 链表的数据元素是一个一个串联在一起的，这一串数据形成的结构就是“链表”。它就像一条自行车“链条”一样。每一个数据元素可以称之为一个节点。 链表在内存中的物理存储空间是非连续、非顺序的。其中每个节点包含两部分，一个是存储数据元素的**“数据域”，另一个是存储下一个节点地址的“指针域”**。 1.2 单链表 1.2.1 单链表图解 1.2.2 单链表的应用 题目描述： 实现一个
数据结构链表入门.docx
01-13
《数据结构链表入门》 链表是一种基础且重要的数据结构，在计算机科学中扮演着不可或缺的角色。本资料主要介绍链表的基本概念、操作以及如何在C++中实现链表。以下将详细阐述链表的原理及其在代码中的体现。 1. ...
java数据结构-链表详解
m0_63526467的博客
05-04 4051
文章目录1.数据结构-链表详解1.1单链表1.1.1单链表节点的尾部添加1.1.2单链表节点的自动排序添加1.1.3单链表节点的修改1.1.4单链表节点的删除1.2单链表面试题1.2.1单链表的有效节点个数1.2.2单链表倒数第k个结点1.2.3单链表反转1.2.4单链表逆序打印1.3双向链表1.3.1双向链表介绍1.3.2双向链表增删改查1.4单向环形链表1.4.1约瑟夫（Josephu）环问题 1.数据结构-链表详解 链表可分为三类： 单链表 双向链表 循环列表 下面具体分析三个链表的应用。 1.1
【数据结构】链表
qq_62361050的博客
07-05 1983
   什么是链表呢？链表是一种数据结构，就像数组，连续地存放一组数据，结构体，连续存放不同类型的一组数据，所以数据结构就是一种数据存放的思想，链表也一样。   那我们为什么要用链表呢？举个例子，比如有一个数组，数组中有若干元素，如果我们要在数组中间增加或删除一个元素，那么我们就要挪动该元素以后的所有数组中的元素，这样的话内存的开销和运算量就会大大增加，这样的话就会十分不灵活。如果是链表的话，对数据的增删的难度就会大大降低。我们看一下为什么：首先我们看一下链表的结构：    链表其实就向一串珠子，把一串珠子串
golang数据结构——链表
lp15929801907的博客
03-10 1443
golang链表详解
数据结构之双链表
m0_61635718的博客
03-24 812
双链表（Double Linked List）是一种线性数据结构，在计算机科学中广泛应用。它是链表的一种复杂形式，每个数据节点（或称为元素）不仅包含数据，还包含两个指针（链接）：一个指向前一个节点（称为前驱指针），另一个指向后一个节点（称为后继指针）。这种结构允许双向遍历，即可以从列表头部向尾部遍历，也可以从尾部向前遍历。
数据结构实验 一元多项式运算 链表应用
07-18
在这个“数据结构实验：一元多项式运算 链表应用”中，我们将深入探讨如何使用C/C++语言来实现一元多项式的数学运算，并将这些运算与链表数据结构相结合。 一元多项式可以表示为一个形式如`a_nx^n + a_{n-1}x^{n-1}...
lb.rar_数据结构 链表
09-20
本资源"lb.rar_数据结构 链表"提供了一些关于链表的C++实现，对学习数据结构的初学者尤其有帮助。 链表是一种线性数据结构，与数组不同，它的元素并不在内存中连续存储。每个元素（节点）包含两部分：数据域，用于...
pp.zip_数据结构链表实验
09-21
在"pp.zip_数据结构链表实验"中，我们聚焦于一个具体的应用场景——学生信息管理。这个实验旨在帮助学生深入理解链表的运作机制，并能够实际操作链表来解决实际问题。 链表是一种线性数据结构，与数组不同，它的...
数据结构链表树图查找排序
09-20
链表、树、图、查找和排序是数据结构领域内的五个关键知识点，它们在编程和算法设计中起着至关重要的作用。 1. **链表**：链表是一种线性数据结构，与数组不同，它不连续存储元素。每个元素称为节点，包含数据和...
数据结构—链式二叉树-C语言
h_number_1的博客
07-11 1017
上述内容，即是我个人对数据结构-链式二叉树-搜索二叉树-C语言的个人见解以及自我实现。若有大佬发现哪里有问题可以私信或评论指教一下我这个小萌新。
数据结构专项-字符串
qq_52241267的博客
07-16 241
面向字符的操作为以字符为单位对数据进行操作，在读的时候将二进制数据转为字符，在写的时候将字符转为二进制数据，这些类都是Reader和Writer的子类。深拷贝和浅拷贝：浅拷贝实际上是复制了被拷贝对象的引用，也就是说浅拷贝的和被拷贝对象指向的是同一块内存空间，而深拷贝则是连同引用的对象也被拷贝，两者指向的是不同的内存空间。然后计算乘法，故之后是*，再计算加法，因此+要在6的前面，不然就是计算4*(x+3)+6了，故选D。中缀表达式中应该先计算x+3，因此后缀表达式中+应该出现在x和3的后面，排除BC。
【Java--数据结构】二叉树
最新发布
2301_80898480的博客
07-16 852
如有错误，欢迎指出~
数据结构第23节 线性搜索
hummhumm的专栏
07-12 386
线性搜索（Linear Search），也称为顺序搜索，是最基本的搜索算法之一。它的工作原理是通过遍历数组或列表中的每一个元素，直到找到目标值为止，或者遍历完所有元素后确定目标值不存在于列表中。线性搜索的时间复杂度为O(n)，其中n是列表中元素的数量。这是因为最坏情况下，你可能需要检查列表中的每一个元素才能找到目标值或确定它不在列表中。
数据结构
2301_80423154的博客
07-12 387
是描述客观事物的符号，是计算机中可以操作的对象，是能被计算机识别并输入给计算机处理的符号集合。数据包括数值类型，字符类型和声音和图片。是组成数据的、有一定意义的基本单位，在计算机中通常作为整体处理。在人类中，数据元素就是人。一个数据元素是由若干数据项组成。例如，人这个数据元素是由姓名，年龄等数据项组成。是性质相同的数据元素的集合，是数据的子集。在不产生混淆的情况下，将数据对象简称数据。性质相同：是指数据元素具有相同数量和类型的数据项。是相互之间存在一种或多种特种关系的数据元素的集合。
Python中的数据结构：五彩斑斓的糖果盒
weixin_42397851的博客
07-12 2059
在Python编程的世界里，数据结构就像是一个个五彩斑斓的糖果盒，每一种糖果都有其独特的味道和形状。这些多姿多彩，形状和味道各异的糖果盒子包括了：List（列表）、Tuple（元组）、Dictionary（字典）和Set（集合）。只有充分了解每种糖果的特性及何时品尝最佳，才是制作美味佳肴的关键。现在，就让我们一起打开这个充满奇幻的数据结构糖果盒，开始一场探索这些有趣糖果盒的奇妙之旅吧！
数据结构之链表详解及示例（C，C#，C++）
qq_35320456的博客
07-13 1066
链表是一种灵活且强大的数据结构，适用于需要频繁插入和删除操作的场景。本文通过C、C#、C++三种语言展示了链表的基本操作，帮助读者理解链表的工作原理。在实际应用中，应根据具体需求选择合适的链表变种，如单向链表、双向链表或循环链表。掌握链表是成为优秀程序员的必经之路。
【数据结构】算法复杂度
yzqy_的博客
07-12 483
在计算机科学中，时间复杂度是一个函数式T(N)。
01基础数据结构之链表
09-14
基础数据结构之链表

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值