leetcode【数据结构简介】《链表》卡片——小结

最新推荐文章于 2021-11-09 11:59:17 发布
最新推荐文章于 2021-11-09 11:59:17 发布
阅读量277 收藏
点赞数
分类专栏： leetcode卡片学习 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AuthurWhywat/article/details/105169407
版权

Author: Authur Whywait， 一个努力学习知识的孩子。好吧，其实是老男孩 \ (0^ ◇^0)/
想看博主的其他所有leetcode卡片学习笔记链接？传送门点这儿

文章目录

复习

回顾单链表和双链表的表现

相同：

  • 它们都无法在常量时间内随机访问数据。
  • 它们都能够在 O(1) 时间内在给定结点之后或列表开头添加一个新结点。
  • 它们都能够在 O(1) 时间内删除第一个结点。

不同 - 体现在删除给定结点(包括最后一个结点)

  • 在单链表中，它无法获取给定结点的前一个结点，因此在删除给定结点之前我们必须花费 O(N) 时间来找出前一结点。
  • 在双链表中，这会更容易，因为我们可以使用“prev”引用字段获取前一个结点。因此我们可以在 O(1) 时间内删除给定结点。

对照

下面是链表和其他数据结构（包括数组，队列和栈）之间的时间复杂度比较：

在这里插入图片描述
通过比较，不难得出结论：

如果你需要经常添加或删除结点，链表可能是一个不错的选择。
如果你需要经常按索引访问元素，数组可能是比链表更好的选择。

程序练习：

1. 合并两个有序列表

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

思路：比较两个链表的表头，将其中较小的一个丢到新的链表里，直至遍历两个链表。

遇到过的报错：runtime error: member access within misaligned address(点击链接，可以查看错误原因)

遇到的第二个问题：
前提：head->next == NULL
错误操作：h = head->next; h = h->next;
错误解释：一个空的东西，哪来的next？ (╯‵□′)╯︵┻━┻

下面是代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){
    struct ListNode * head = (struct ListNode *)malloc(sizeof(struct ListNode));
    head->val=0; 
    head->next=NULL;
    struct ListNode * h = head, * h1 = l1, * h2 = l2;

    while(h1 || h2){
        if(h1 && h2){
            struct ListNode * temp = (struct ListNode *)malloc(sizeof(struct ListNode));
            temp->val = h1->val < h2->val ? h1->val : h2->val;
            temp->next = NULL;
            h->next = temp;
            h = h->next;
            if(h->val==h1->val) h1 = h1->next;
            else h2 = h2->next;
        }
        else if(h1 && !h2){
            struct ListNode * temp = (struct ListNode *)malloc(sizeof(struct ListNode));
            temp->val = h1->val;
            temp->next = NULL;
            h->next = temp;
            h = h->next;
            h1 = h1->next;
        }
        else{
            struct ListNode * temp = (struct ListNode *)malloc(sizeof(struct ListNode));
            temp->val = h2->val;
            temp->next = NULL;
            h->next = temp;
            h = h->next;
            h2 = h2->next;
        }
    }
    return head->next;
}

在这里插入图片描述
想清楚情况类型，分情况讨论，这种问题就能轻易解决啦~（当然不要像我一样犯低级错误 (╯‵□′)╯︵┻━┻ ）

2. 两数相加

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

思路：回想数组里面的两数相加，是不是就觉得so简单了呢~
这题其实就是关乎进位 - 满十进一

代码直接丢在下头

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2){
    
    struct ListNode *l3 = (struct ListNode*)malloc(sizeof(struct ListNode));
    l3->val = 0; l3->next = NULL;
    struct ListNode* h1 = l1, * h2 =l2, * h3 = l3; 
    int flag = 0;


    while(h1 != NULL && h2 != NULL){      
        
        if(flag){
            h3->val = 1;
            flag = 0;
        }

        h3->val += (h1->val + h2->val);
        if(h3->val >= 10){
            h3->val =  h3->val % 10;
            flag = 1;
        }
        h1 = h1->next;
        h2 = h2->next;
        if((h1 || h2) && !h3->next){
            struct ListNode *tempNode = (struct ListNode*)malloc(sizeof(struct ListNode));
            tempNode->val = 0;
            tempNode->next = NULL;
            h3->next = tempNode;
            h3 = h3->next;
        }
        
    }

    if (!h1 && !h2 && flag){
        if(!h3->next){
            struct ListNode *tempNode = (struct ListNode*)malloc(sizeof(struct ListNode));
            tempNode->val = 1;
            tempNode->next = NULL;
            h3->next = tempNode;
        }
    }

    if(h1){
        while(h1){
            h3->val = flag + h1->val;
            flag = 0;
            if(h3->val >= 10){
                h3->val = h3->val % 10;
                flag = 1;
            }
            h1 = h1->next;
            if(!h3->next && h1){
                struct ListNode *tempNode = (struct ListNode*)malloc(sizeof(struct ListNode));
                tempNode->val = 0;
                tempNode->next = NULL;
                h3->next = tempNode;
            }
            if(h1) h3 = h3->next;
        }
        if(flag && !h3->next){
            if(!h3->next){
                struct ListNode *tempNode = (struct ListNode*)malloc(sizeof(struct ListNode));
                tempNode->val = 1;
                tempNode->next = NULL;
                h3->next = tempNode;
            }
        }
        
    }
    else if(h2){
        while(h2){
            h3->val = flag + h2->val;
            flag = 0;
            if(h3->val >= 10){
                h3->val = h3->val % 10;
                flag = 1;
            }
            h2 = h2->next;
            if(!h3->next && h2){
                struct ListNode *tempNode = (struct ListNode*)malloc(sizeof(struct ListNode));
                tempNode->val = 0;
                tempNode->next = NULL;
                h3->next = tempNode;
            }
            if(h2) h3 = h3->next;
        }
        if(flag && !h3->next){
            if(!h3->next){
                struct ListNode *tempNode = (struct ListNode*)malloc(sizeof(struct ListNode));
                tempNode->val = 1;
                tempNode->next = NULL;
                h3->next = tempNode;
            }
        }
    }
    else ;//puts("something is wrong!");

    return l3;
}

在这里插入图片描述

其实学到这里的时候，我发现，这个程序是我在leetcode写的第二个程序(当初花了近乎一天的时间写出这个程序之后，我发现，单单做题是没用的，还需要吸收相关知识，不管是算法还是数据结构）。所以，这道题之后，我开始学习leetcode里面的卡片，并在CSDN上努力吸收知识。回想起来，我与刚进入leetcode的我，从自我感觉的角度来说，差别还是有的，不说解题的速度，更多的是在于面对难解问题时候内心的无所惧。继续加油！

3. 扁平化多级双向链表

多级双向链表中，除了指向下一个节点和前一个节点指针之外，它还有一个子链表指针，可能指向单独的双向链表。这些子列表也可能会有一个或多个自己的子项，依此类推，生成多级数据结构，如下面的示例所示。

给你位于列表第一级的头节点，请你扁平化列表，使所有结点出现在单级双链表中。

输入：head = [1,2,null,3]
输出：[1,3,2]
解释：
输入的多级列表如下图所示：
1—2---NULL
|
3—NULL

方法：把到处分叉的双向链表捋直了。觉得理不清就画个图，事半功倍
代码写的C++, 因为这道题leetcode没有给出C的语言环境(╯‵□′)╯︵┻━┻

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* prev;
    Node* next;
    Node* child;
};
*/
class Solution {
public:
    Node* flatten(Node* head) {
        if(!head) return nullptr;
        Node *cur=head;
        while(cur){
            Node* nxt = cur->next;
            if(cur->child){
                Node * child1=cur->child;
                cur->next=child1;
                child1->prev=cur;
                cur->child=nullptr;

                Node *tail=child1;
                while(tail&&tail->next) tail=tail->next;

                tail->next=nxt;
                if(nxt) nxt->prev=tail;

            }
            cur = cur->next;
        }
        return head;
    }
};

在这里插入图片描述

4. 复制带随机指针的链表

给定一个链表，每个节点包含一个额外增加的随机指针，该指针可以指向链表中的任何节点或空节点。

要求返回这个链表的 深拷贝。

我们用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val, random_index] 表示：

  • val：一个表示 Node.val 的整数。
  • random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为 null 。

深拷贝是什么鬼？难道还有浅拷贝？于是我陷入了深深的沉思··· ok, fine. 我其实是去查资料了(这种东西单单靠脑子肿么想得出来)。深拷贝与浅拷贝传送门在这儿。（看到这里的你一定黑人问号脸：传送门搁那儿呢？谁又能想到传送门是这儿后面的那个句号呢？我真是个小机灵鬼(●ˇ∀ˇ●)）

"沉思"结束，我马上一顿操作
主要步骤分为两步：

  1. 构建一个新的链表，除了其中每个结点的随机指针h1->random==NULL都为NULL，和原链表并无其他差别；
  2. 新链表构建好之后，我们利用计数器index，依次遍历新链表，对每个结点的随机指针进行赋值。
/**
 * Definition for a Node.
 * struct Node {
 *     int val;
 *     struct TreeNode *next;
 *     struct TreeNode *random;
 * };
 */

struct Node* copyRandomList(struct Node* head) {
	if(!head) return NULL;

    /*使用next将整个链表构建起来*/
    
    struct Node *head1 = (struct Node *)malloc(sizeof(struct Node));
    head1->val = head->val;
    head1->next = NULL;
    head1->random = NULL;

    struct Node* h = head, * h1 = head1;

    while(h->next){
        h = h->next;
        struct Node * temp = (struct Node *)malloc(sizeof(struct Node));
        temp->val = h->val;
        temp->next = NULL;
        temp->random = NULL;
        
        h1->next = temp;
        h1 = h1->next;
    }
    
    /*处理那个随机指针*/
    h = head; h1 = head1; 
    while(h){
        if(!h) break;

        int index=0;
        struct Node * cur=head, * cur1=head1;

        if(h->random){
            while(cur && cur!=h->random){
                index++;
                cur = cur->next;
            }
            while(index){
                index--;
                cur1 = cur1->next;
            }
            h1->random = cur1;
        }
        else h1->random = NULL;
        
        h = h->next;
        h1 = h1->next;
    }
    return head1;
}

在这里插入图片描述
PS：此题所用到的深拷贝，只是深拷贝里面比较简单的一种。过些日子要写一篇blog，专门总结整理一下深拷贝的相关知识点，包括深拷贝与浅拷贝的区别以及深拷贝的程序实现等内容。ヾ(≧ ▽ ≦)ゝ

5. 旋转链表

给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。

输入: 1->2->3->4->5->NULL, k = 2
输出: 4->5->1->2->3->NULL
解释:
向右旋转 1 步: 5->1->2->3->4->NULL
向右旋转 2 步: 4->5->1->2->3->NULL

如果你是随着我的整个leetcode卡片学习系列一路下来，那你一定是知道我曾经遇到过一道题——旋转数组，这道题的解法颇多，详情看链接。(这次传送门不在句号上，惊喜不？( ¯(∞)¯ ) )

言归正传，我们可以用 旋转数组 里面的思想来处理这道题目么？

自然是可以的！
不管是暴力换头术，辅助链表，还是其他方法，都可以解决这类问题。
但是对于链表而言，用环来做，不香吗？

方法：

  1. 最后一个节点的next指针指向头节点
  2. 找到相应的位置，断掉环，返回新的头节点。

实际操作小技巧：使用%取余，减少不必要的循环次数

struct ListNode* rotateRight(struct ListNode* head, int k){
	/*如果为空，直接返回NULL*/
    if(!head) return NULL;

	/*得到节点个数size*/
    int size=1;
    struct ListNode* cur=head;
    while(cur->next){
        cur = cur->next;
        size++;
    }
    
    /*如果右移位数k为size的整数倍，则直接返回原链表，right为头节点右移的位数*/
    int right = size - (k%size); 
    if(size==right) return head;
    
	/*尾首相连，得到一个环，找到新的头节点的位置以及新的最后一个节点的位置*/
    cur->next = head;
    struct ListNode* newtail=cur;
    while(right){
        newtail = newtail->next;
        right--;
    }

	/*断环*/
    head = newtail->next;
    newtail->next = NULL;
    
	/*返回新的头节点*/
    return head;
}

在这里插入图片描述

都看到这里了，确定不点个赞再走？ (╯‵□′)╯︵┻━┻

AuthurLEE
关注
专栏目录
【LeetCode刷题——数据结构篇】
superplumblossm的博客
01-13 1727
2022寒假LeetCode刷题——Task01：链表 简介：本人大一学过C++，此后几年间几乎没有使用过，可以称得上是小白了。所以此次刷题会是比较困难的过程，同时也是通过这次的组队学习捡拾起以前的知识，更重要是扩充和巩固。所以这篇blog篇幅可能较长且也有基础型知识的回顾，也是我在做题过程中一步步完成的记录。 一、数组基础题目 （题号：0189）旋转数组 题目：给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。 首先要弄清楚的点： vector和array的区别 双指针法 ...
LeetCode148——排序链表
清风阁
01-10 1418
我的LeetCode代码仓：https://github.com/617076674/LeetCode 原题链接：https://leetcode-cn.com/problems/sort-list/description/ 题目描述： 知识点：归并排序、链表 思路：自顶向下的归并排序 本题和LeetCode147——对链表进行插入排序其实是同一个问题——对链表进行排序操作，但是本题...
data-structure-cards:基于卡片的数据结构方法
06-14
数据结构卡 一种基于数据结构的方法卡。 我们希望这些卡片能够： 作为独立的交易卡 来玩游戏的规则 像学习的“抽认卡”一样 是选择数据结构的快速参考卡 有额外的历史信息，比如谁首先发现它们 ###想贡献吗？ 这个项目才刚刚开始，我们需要你的帮助来实现它！ 我们欢迎包含新数据结构或现有卡片的新细节的拉取请求。 如果您不知道将新数据结构放在哪里，请将其添加到 cardsets/sortme.txt 中。 另外，请在创建新卡片时坚持抽象和具体的模板——我们需要所有卡片之间的统一性才能使系统正常工作。 同样，在向现有卡片添加信息时，请注意保持模板完整，如果还没有，请将其强加到卡片上。 大胆点！ （但也要小心。） 如果您想贡献艺术或规则集，请提交问题（或 PM dxnn）以便我们讨论。 这非常令人兴奋！！！ :thumbs_up: :hamburger: :thumbs_up:
leetcode【数据结构简介】《二叉树》卡片——总结
AuthurLEE's Blogs
04-03 307
Authur Whywait 做一块努力吸收知识的海绵 程序练习 从中序和后序遍历序列构造二叉树 从中序与后序遍历序列构造二叉树 填充每个节点的下一个右侧节点指针 填充每个节点的下一个右侧节点指针 II 二叉树的最近公共祖先 二叉树的序列化与反序列化
卡牌排序的链表实现
qq_41890466的博客
11-09 382
import time import random #卡牌排序适用链表节点 class Node: def __init__(self,x=None): self.val=x self.next_node=None #卡牌排序适用链表 class LinkList: def __init__(self): self.head=None def list_print(self): node=self.head .
leetcode探索卡片再哪里-front-end-documentation::fire:一份精选的前端有用资源列表。此列表已根据我作为前端的多年经验
06-30
leetcode 探索区别再哪里 前端文档 2020 :rocket: :fire: :fire: 一个很棒的前端有用资源的精选列表 :fire: 对我来说，这是保持最新状态的最佳网站 => 指数 辅助功能 - A11Y 描述 网址 ChromeVox 扩展程序 网页内容无障碍指南 2.0 牢记网络可访问性 很棒的工具，可以告诉您网页的可访问性 WAI - 咏叹调模式 审计中的开发人员工具插件 ARIA 角色 无障碍文章 Angular 一般和 Angular 5+ 描述 网址 Angular 2 的良好基础知识和基础知识 Angular 1.x 项目的高级结构 Rangle.io：Angular 2 培训 Vaddin = Angular 2 + Material Design + PolymerJS 使用 Angular 制作的项目 使用 angular 构建的站点示例 站点 tu 使用 Angular 运行示例 角度最佳实践 Pluralsigh Angular 2 获取 Angular 2 在 heroku 上部署 angular 2 带有角度材质的自定义主题 Augury 调试 Angular 应用程序 在 Herok
leetcode探索卡片再哪里-Interview-Preparation:Leetcode上问题的解决方案，使用Golang和JAVA
06-30
leetcode 探索区别再哪里Leetcode 问题的解决方案，使用 Golang 和 JAVA。 如果您有兴趣提供帮助或者您有不同编程语言的解决方案，请随时提出拉取请求。 数据结构 数组和字符串 该数组在 Java 中具有固定大小。 ArrayLists 具有动态调整大小功能。 当 Array 已满时，它的大小加倍。 复制字符串是一项昂贵的操作，另一种方法是使用 String Builder。 String Builder 是一个可调整大小的字符串数组。 String Builder 可以在需要时转换为 String。 哈希表 它是键值的映射。 如何实施？ 使用链表数组和哈希函数。 它是如何工作的？ 使用哈希函数计算密钥的哈希码。 结果将映射到数组中的一个索引。 例如（键 % ArrayLength）。 键和值将存储在该索引中。 碰撞处理： 由于数组冲突中存在无限值和有限可能的哈希码或索引。 如何处理碰撞？ 使用链表链接：这是我们制作具有映射到链表的数组的项目哈希表的最常见方式。 键和值存储在链表中。 在最坏情况下，访问的时间复杂度为 O(n)。 用二叉搜索树链接：碰撞存储在二叉搜
python数据结构实现（一）：数组和链表及相关LeetCode题 数组和链表.pdf
04-18
在Python中，数组和链表是两种基本的数据结构，它们在处理数据时有着不同的特性和应用场景。本篇文章将深入探讨这两种数据结构的实现，并结合LeetCode题目进行实战演练。 首先，我们来看数组。数组是一种线性表的...
leetcode数据结构的一些总结
最新发布
04-14
在LeetCode上，常见的数据结构包括数组、链表、栈、队列、哈希表、树、图、堆和位运算等。 1. **数组**：是最基本的数据结构，提供了直接访问元素的能力。LeetCode中的数组问题涵盖了单个数组、双指针、滑动窗口、...
leetcode小偷---:——
07-01
要掌握这三点，除了掌握基础算法之外，还需要了解算法设计的常用思想和模式，并且要掌握将题目转成数据模型，并进一步用数据结构实现数据模型的一般方法。 1.2 数据模型 一个完整的算法实现应该包含三个重要的组成...
leetcode【数据结构简介】《链表》卡片——单链表
AuthurLEE's Blogs
03-27 236
文章目录单链表简介结点结构单链表的添加操作单链表的删除操作程序练习：设计链表 单链表简介 单链表中的每个结点不仅包含值，还包含链接到下一个结点的引用字段。通过这种方式，单链表将所有结点按顺序组织起来。 蓝色箭头显示单个链接列表中的结点是如何组合在一起的。 结点结构 //definition for singly-linked list. struct SinglyListNode{ in...
leetcode【数据结构简介】《链表》卡片——经典问题
AuthurLEE's Blogs
03-27 272
一些关于单链表的经典问题以及相关编程题， 内含多种解题方法、注意事项、心得，甚至一些吐槽！只有你想不到~
leetcode【来学习一下】《二分查找》卡片 - 概览及背景
AuthurLEE's Blogs
04-10 249
二分查找是计算机科学中最基本、最有用的算法之一。 它描述了在有序集合中搜索特定值的过程。
LeetCode刷题Tag专题打卡目录
NayelyA的博客
04-11 631
LeetCode刷题Tag打卡目录 持续更新… 专题一：二分专题 lc 69. Sqrt(x) lc 35. Search Insert Position lc 34. Find First and Last Position of Element in Sorted Array lc 74. Search a 2D Matrix lc 153. Find Minimum in Rotated...
LeetCode卡片探索-中级算法
屏幕里的日与夜
06-28 1266
卡片探索-中级算法数组和字符串三数之和矩阵置零字母异位词分组无重复字符的最长子串最长回文子串递增的三元子序列链表树和图回溯算法排序和搜索动态规划设计问题数学其他 LeetCode上知识卡片之中级算法的刷题记录 数组和字符串 三数之和 把数组排序后，遍历数组，每次固定当前元素，然后用双指针再后续数组里面搜索与它相加为0的元素组合。 class Solution: def threeSum(self, nums: List[int]) -> List[List[int]]: n=l
leetcode 探索 链表 扁平化多级双向链表
KylinMountain的笔记
06-26 238
题目 多级双向链表中，除了指向下一个节点和前一个节点指针之外，它还有一个子链表指针，可能指向单独的双向链表。这些子列表也可能会有一个或多个自己的子项，依此类推，生成多级数据结构，如下面的示例所示。 给你位于列表第一级的头节点，请你扁平化列表，使所有结点出现在单级双链表中。 输入：head = [1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12] 输出：[1,2,3,7,8,11,12,9,10,4,5,6] 解释： 输入的多级列表如下图所示： 扁平
力扣——扁平化多级双向链表（深度优先算法）
zhoushimiao1990的博客
08-29 641
题目描述： 多级双向链表中，除了指向下一个节点和前一个节点指针之外，它还有一个子链表指针，可能指向单独的双向链表。这些子列表也可能会有一个或多个自己的子项，依此类推，生成多级数据结构，如下面的示例所示。 给你位于列表第一级的头节点，请你扁平化列表，使所有结点出现在单级双链表中。 题解： 方法一：递归的深度优先搜素 我们可能会疑问什么情况下会使用这样的数据结构。其中一个场景就是 git 分支的简化版本。通过扁平化多级列表，可以认为将所有 git 的分支合并在一起。 首先，为了清楚扁..
LeetCode 翻转卡片游戏
hestyle的博客
05-21 1715
在桌子上有 N 张卡片，每张卡片的正面和背面都写着一个正数（正面与背面上的数有可能不一样）。 我们可以先翻转任意张卡片，然后选择其中一张卡片。 如果选中的那张卡片背面的数字 X 与任意一张卡片的正面的数字都不同，那么这个数字是我们想要的数字。 哪个数是这些想要的数字中最小的数（找到这些数中的最小值）呢？如果没有一个数字符合要求的，输出 0。 其中, fronts[i] 和 backs[i] 分别代...
LeetCode——430扁平化多级双向链表
CSDN的博客
09-02 205
问题描述： 您将获得一个双向链表，除了下一个和前一个指针之外，它还有一个子指针，可能指向单独的双向链表。这些子列表可能有一个或多个自己的子项，依此类推，生成多级数据结构，如下面的示例所示。 扁平化列表，使所有结点出现在单级双链表中。您将获得列表第一级的头部。 输入: 1---2---3---4---5---6--NULL | 7---8---9---1...
Python数据结构实现：动态数组与链表解析及LeetCode相关题目
本文主要介绍Python中数据结构的基础——数组和链表，并结合LeetCode题目探讨其应用。在Python中，虽然内置的`list`类型可以完成类似数组的功能，但在处理大量数据时，由于其动态扩容的特性，可能会导致性能下降。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

AuthurLEE

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

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

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

打赏作者

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

抵扣说明：

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

余额充值