【算法篇】链表类（笔记）

最新推荐文章于 2024-10-15 19:28:18 发布
最新推荐文章于 2024-10-15 19:28:18 发布
阅读量958 收藏 22
点赞数 21
分类专栏： 算法 文章标签： 算法 链表 笔记 leetcode c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CXDNW/article/details/142179618
版权

目录

一、移除链表元素

二、设计链表

三、反转链表

1.双指针法

2. 递归法

四、两两交换链表中的节点

五、删除链表的倒数第N个节点

六、面试题 02.07.链表相交

七、环形链表II

一、移除链表元素

203. 移除链表元素 - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/remove-linked-list-elements/description/

        给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

示例 1：
输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]
示例 2：
输入：head = [], val = 1
输出：[]
示例 3：
输入：head = [7,7,7,7], val = 7
输出：[]

思路：

        设置一个虚拟头结点移除节点操作。最后 return 头结点的时候，应为 return h->next;， 这才是新的头结点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* h = new ListNode(0); // 头
        h->next = head;
        ListNode* cur = h;
        while(cur->next != NULL)
        {
            if(cur->next->val == val)
            {
                // 删除后面的一个节点
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            }
            else
            {
                cur = cur->next;
            }
        }
        return h->next;
    }
};

二、设计链表

707. 设计链表 - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/design-linked-list/description/

        选择使用单链表或者双链表，设计并实现自己的链表。

        单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

        如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

  • MyLinkedList() 初始化 MyLinkedList 对象。
  • int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
  • void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
  • void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
  • void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
  • void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。
示例：
输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]

解释
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2);    // 链表变为 1->2->3
myLinkedList.get(1);              // 返回 2
myLinkedList.deleteAtIndex(1);    // 现在，链表变为 1->3
myLinkedList.get(1);              // 返回 3

class MyLinkedList {
public:
    // 定义链表节点结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val): val(val), next(nullptr){}
    };

    // 初始化链表
    MyLinkedList() {
        _dummyHead = new LinkedNode(0); // 虚拟头结点
        _size = 0;
    }

    // 获取到第index个节点数值，如果index是非法数值直接返回-1， 注意index是从0开始的，第0个节点就是头结点
    int get(int index) {
        if (index > (_size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* cur = _dummyHead->next;
        while(index--){ // 如果--index 就会陷入死循环
            cur = cur->next;
        }
        return cur->val;
    }

    // 在链表最前面插入一个节点，插入完成后，新插入的节点为链表的新的头结点
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }

    // 在链表最后面添加一个节点
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }

    // 在第index个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果index大于链表的长度，则返回空
    // 如果index小于0，则在头部插入节点
    void addAtIndex(int index, int val) {

        if(index > _size) return;
        if(index < 0) index = 0;        
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }

    // 删除第index个节点，如果index 大于等于链表的长度，直接return，注意index是从0开始的
    void deleteAtIndex(int index) {
        if (index >= _size || index < 0) {
            return;
        }
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur ->next;
        }
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        //delete命令指示释放了tmp指针原本所指的那部分内存，
        //被delete后的指针tmp的值（地址）并非就是NULL，而是随机值。也就是被delete后，
        //如果不再加上一句tmp=nullptr,tmp会成为乱指的野指针
        //如果之后的程序不小心使用了tmp，会指向难以预想的内存空间
        tmp=nullptr;
        _size--;
    }

    // 打印链表
    void printLinkedList() {
        LinkedNode* cur = _dummyHead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
private:
    int _size;
    LinkedNode* _dummyHead;
};

三、反转链表

206. 反转链表 - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/reverse-linked-list/description/

        给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

 

示例 2：
输入：head = [1,2]
输出：[2,1]
示例 3：
输入：head = []
输出：[]

1.双指针法

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = nullptr;
        ListNode* cur = head;
        ListNode* tmp;
        while(cur != nullptr)
        {
            tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
};

        首先定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null。然后开始反转，首先要把 cur->next 节点用tmp指针保存。接下来，就是循环走如下代码逻辑了，继续移动pre和cur指针。最后，cur 指针已经指向了null，循环结束，链表也反转完毕了。 此时 pre指针就指向了新的头结点。

2. 递归法

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:

    ListNode* reverse(ListNode* pre, ListNode* cur)
    {
        if(cur == nullptr) {
            return pre;
        }

        ListNode* tmp = cur->next;
        cur->next = pre;

        return reverse(cur, tmp);
    }

    ListNode* reverseList(ListNode* head) {
        // 递归法
        return reverse(nullptr, head);
    }
};

四、两两交换链表中的节点

24. 两两交换链表中的节点 - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/swap-nodes-in-pairs/description/

        给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

 

示例 1：
输入：head = [1,2,3,4]
输出：[2,1,4,3]
示例 2：
输入：head = []
输出：[]
示例 3：
输入：head = [1]
输出：[1]

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head == nullptr) return nullptr;
        if(head->next == nullptr) return head;

        ListNode* h = new ListNode(0);
        h->next = head;
        ListNode* cur = h;
        while(cur->next != nullptr && cur->next->next != nullptr)
        {
            ListNode* nxt = cur->next;
            
            // 交换
            cur->next = nxt->next;
            nxt->next = nxt->next->next;
            cur->next->next = nxt;
            
            cur = nxt;
        }
        ListNode* result = h->next;  // 删除头节点
        delete h;
        return result;
    }
};

五、删除链表的倒数第N个节点

19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/remove-nth-node-from-end-of-list/description/

        给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

实例1：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：
输入：head = [1], n = 1
输出：[]
示例 3：
输入：head = [1,2], n = 1
输出：[1]

思路：

（1）定义 fast 指针 和 slow 指针，初始值为 虚拟头结点。

（2）fast 首先走 n + 1 步 ，为什么是 n+1 呢，因为 只有这样同时移动的 时候 slow 才能 指向删除节点的 上一个节点（方便做 删除操作）。

（3）fast 和 slow 同时移动，直到 fast 指向末尾。

（4）删除 slow 指向的下一个节点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if(head->next == nullptr && n == 1) return nullptr;
        if(head->next == nullptr && n == 0) return head;

        // 快满指针
        ListNode* h = new ListNode(0);
        h->next = head;
        ListNode* left = h;
        ListNode* right = h;

        while(n--)
        {
            right = right->next;
        }
        while(right->next != nullptr)
        {
            right = right->next;
            left = left->next;
        }

        if(right->next == nullptr)
        {
            ListNode* tmp = left->next;
            left->next = left->next->next;
            delete tmp;
        }
        return h->next;
    }
};

六、​​​​​​​面试题 02.07.链表相交

面试题 02.07. 链表相交 - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/description/

        给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

示例 1：
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：
输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

思路：

         设 curA 指向 链表 A 的头结点，curB 指向 链表 B 的头结点。求出两个链表的长度，并求出两个链表长度的 差值，然后让 curA 移动到，和 curB 末尾对齐的 位置。此时就可以比较 curA 和 curB 是否相同，如果 不相同，同时向后移动 curA 和 curB，如果遇到 curA == curB，则找到交点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        // 只能先对齐
        int lenA = 0;
        int lenB = 0;
        ListNode* curA = headA;
        ListNode* curB = headB;
        int relenA = 0;  // A、B 对应得下标值点
        int relenB = 0;
        // 计算长度
        while(curA != NULL)
        {
            curA = curA->next;
            lenA++;
        }
        while(curB != NULL)
        {
            curB = curB->next;
            lenB++;
        }

        int len = lenA - lenB;
        if(len > 0)
        {
            // A 长
            relenA += len;
            while(len--)
            {
                headA = headA->next;
            }
        }
        else if(len < 0)
        {
            // B 长
            len = abs(len);
            relenB += len;
            while(len--)
            {
                headB = headB->next;
            }
        }

        // 判断
        while(headA != NULL && headB != NULL)
        {
            if(headA == headB)
            {
                return headA;
            }
            headA = headA->next;
            headB = headB->next;
            relenA++;
            relenB++;
        }

        return NULL;
    }
};

七、环形链表II

142. 环形链表 II - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/linked-list-cycle-ii/description/

        给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

        如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

        不允许修改 链表。

示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：
输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

思路：

        可以使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指 针 每次移动 两个节点，slow 指针 每次移动 一个节点，如果 fast 和 slow指针在途中 相遇 ，说明这个 链表有环。

        fast 指针一定先进入环中，如果 fast 指针 和 slow 指针相遇的话，一定是 在环中相遇，这是毋庸置疑 的。

        因为 fast 是走两步，slow 是走一步，其实相对于 slow 来说，fast 是一个节点一个节点的 靠近 slow 的，所以 fast 一定 可以 和 slow 重合。

        假设从 头结点到环形入口节点 的节点数为 x。 环形入口节点到 fast 指针 与 slow 指针 相遇节点 节点数为 y。 从 相遇节点 再到环形入口 节点节点数为 z。如下图：

        那么相遇时： slow 指针 走过的节点数为: x + y， fast 指针走过的节点数：x + y + n (y + z)，n 为 fast 指针在环内走了 n 圈 才遇到 slow 指针， （y+z）为 一圈内节点的个数 A。

        因为 fast 指针 是一步走两个节点，slow 指针 一步走一个节点， 所以 fast 指针 走过的节点数 = slow 指针走过的节点数 * 2：(x + y) * 2 = x + y + n (y + z)。所以 x = n (y + z) - y 。整理公式得：x = (n - 1) (y + z) + z ，这里 n 一定是大于 等于 1 的，因为 fast 指针 至少要多 走一圈才能 相遇 slow 指针。

        当 n 为 1 的时，公式就化解为 x = z，这表示 fast 指针 在环形里 转了一圈 之后，就 遇到了 slow 指针 了。所以，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        // 快慢指针
        ListNode* slow = head;
        ListNode* fast = head;
        while(fast != NULL && fast->next != NULL)
        {
            slow = slow->next;
            fast = fast->next->next;

            // 环内相遇节点
            if(slow == fast)
            {
                ListNode* index1 = head;
                ListNode* index2 = slow;
                while(index1 != index2)
                {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index1;
            }
        }
        return NULL;
    }
};

CXDNW
关注
专栏目录
数据结构与算法学习笔记
ityqing的博客
09-25 34万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
Leetcode刷题笔记——排序算法篇
qq_42898642的博客
02-16 1723
本文给大家介绍了面试中常考的关于排序问题的算法题，本文重点介绍了计数排序、快速排序、堆排序（重点）、插入排序、归并排序（重点）、桶排序、还有自定义排序规则
算法通关村第一关——链表青铜挑战笔记
qq_58073221的博客
10-15 645
算法通关村第一关——链表青铜挑战笔记
链表算法题总结
weixin_38184628的博客
05-01 805
链表作为一个基础的数据结构，在开发中经常被使用。链表往往使用如下的数据结构来表示，struct node 表示链表中的一个节点，data 表示节点的数据；next 表示这个节点指向的下一个节点，如果是链表的尾节点，那么 next 是空。在使用链表的时候，head 指针是需要维护的，head 是链表的头节点。在使用中，head 可以包含具体的数据，表示链表的第一个节点；head 也可以不包含数据，head->next 表示链表的第一个节点。
算法通关村第一关———链表青铜挑战笔记
m0_74313947的博客
07-17 1147
通过类来构建节点，用next指针将节点连起来。
数据结构与算法——链表
LoveXming的博客
03-12 1623
数据结构与算法——链表
【尚硅谷】Java数据结构与算法笔记03 - 链表
热门推荐
知不足而奋进，望远山而前行
12-07 2万+
链表是有序的列表，它在内存中的存储如下：单链表(带头结点) 逻辑结构示意图如下：使用带 head 头的单向链表实现 - 水浒英雄排行榜管理完成对英雄人物的增删改查操作 输出： 2.3 面试题（新浪、百度、腾讯） 求单链表中有效节点的个数 查找单链表中的倒数第k个结点 单链表的反转 从尾到头打印单链表 合并两个有序链表 三、双向链表 3.1 思路分析 使用带 head 头的双向链表实现 - 水汻英雄排行榜管理单向链表的缺点分析:分析 双向链表的遍历, 添加, 修改, 删除的操作思路 ===>===>===
【❤️算法笔记❤️】-每日一刷-21、合并两个有序链表
令狐_JackieHao的博客
03-06 434
链表类-刷题笔记
【算法模板】链表篇—（附牛客习题）
小宝的博客
07-15 3038
我们必须先学会承受，再学会参与。承受是需要阅历和沉实的，参与也有需要勇气和激情。生活就是在热情与平淡中慢慢的磨合的。
算法笔记3_算法笔记_浙大_
09-30
《算法笔记3》是针对浙江大学计算机科学与技术专业学生及准备参加PAT（全国计算机等级考试——编程类）的考生编写的参考资料，主要采用C/C++语言进行讲解。这本书旨在帮助读者提升算法理解与编程能力，为机试和PAT...
LeetCode算法数据结构专训笔记,
03-26
【LeetCode算法数据结构专训笔记】 LeetCode是一个广受欢迎的在线平台，它提供了大量的算法和数据结构问题供用户练习和提升。通过刷LeetCode的题目，你可以显著提高自己的算法能力，尤其是对于链表、树等数据结构的...
算法笔记.胡凡
03-23
《算法笔记.胡凡》是一本深入浅出的算法学习资料，主要针对想要提升算法能力的读者，无论你是初学者还是有一定基础的程序员，都能从中受益。这本书通过丰富的实例和清晰的代码，帮助读者理解并掌握各种算法的核心...
Acwing算法基础课学习笔记
togph的博客
04-16 1794
Acwing 算法基础学习笔记
34. 在排序数组中查找元素的第一个和最后一个位置
weixin_61695887的博客
10-12 461
请你找出给定目标值在数组中的开始位置和结束位置。给你一个按照非递减顺序排列的整数数组。你必须设计并实现时间复杂度为。如果数组中不存在目标值。
利用GPU的OpenCL和MLC-LLM框架运行小语言模型-地瓜RDK X5开发板-非量产算法仅供整活
吴超的博客
10-12 1139
百分之零的BPU占用，几乎百分之零的CPU占用，将主要计算资源保留给主要算法。采用int4量化，内存和带宽占用理论上int8量化的一半，空余内存4.1GB。采用GPU作为计算部件，摸着通用计算的尾巴。理论上，可以使用X5的这颗支持OpenCL的GPU运行HuggingFace上面的任何模型。所有涉及的代码仓库或者模型权重均为Apache 2.0协议开源。
目标检测——Libra R-CNN算法解读
lishanlu136的博客
10-15 787
目标检测Libra R-CNN算法解读
图算法之Floyd-Warshall 算法（全点对最短路径）详细解读
m0_61840987的博客
10-11 774
Floyd-Warshall 算法是求解全点对最短路径的经典算法，适用于需要处理负权边的场景。它的时间复杂度较高，因此适合处理顶点较少的密集图，而不是稀疏图。如果图中存在负权环，该算法可以用来检测。
专题：数组（已完结）
qq_23923713的博客
10-15 74
数组
【从零开始的LeetCode-算法】3099. 哈沙德数
最新发布
qq_40878316的博客
10-15 102
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
C++学习：数据结构与算法分析笔记
数据结构包括数组、链表、栈、队列、树、图等，而算法则涉及排序、查找、图算法等。学习者需要理解每种数据结构的特点、优缺点以及适用场景，同时掌握不同算法的实现方式和效率。 2. **权衡概念**：在选择数据结构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值