【算法】链表的基本操作和高频算法题

链表高频算法题精讲:环形检测与合并有序链表 给定一个链表,判断链表中是否有环。如果链表中有某个节点可以通过连续跟踪 next 指针再次到达,则链表中存在环。输入:head = [3,2,0,-4](尾节点指向索引1)输出:true。 阅读详情

🚀 优质资源分享 🚀

学习路线指引(点击解锁)知识定位人群定位
🧡 Python实战微信订餐小程序 🧡进阶级本课程是python flask+微信小程序的完美结合,从项目搭建到腾讯云部署上线,打造一个全栈订餐系统。
💛Python量化交易实战💛入门级手把手带你打造一个易扩展、更安全、效率更高的量化交易系统

链表的基本操作

链表的基础操作有查找、删除、添加。

查找

先定义一下链表的数据结构:

class DataNode{
    int key;
    int value;
    
    DataNode pre;
    DataNode next;
    
    public DataNode(){};
    
    public DataNode (int key,int value){
        this.key = key;
        this.value = value;
    }
}

​ 其中的key和value就是节点实际存储的值。pre和next分别指向前一个节点和下一个节点。一般的单向链表只有next,我这里定义的是双向链表。查找操作就是从头节点,一直遍历next,直到找到目标节点为止。可以用while循环或者递归实现,找到目标节点就跳出或返回即可,时间复杂度为O(n)。

删除

以上面的双向链表为例,演示一下删除操作。我们假设有三个节点A、B、C,现要删除B节点。把A.next指向C,C.pre指向A。中间的B节点就不在链路上了,会被垃圾收回器给回收掉。

public void delNode(DataNode node){
    node.pre.next = node.next;
    node.next.pre = node.pre;
}

上面的代码初看可能有点绕,其实链表除了查找操作,都有点绕,建议画图理解。其中node.pre.next就是上一个节点的下一个节点,把它改成node.next,就相当于让上一个节点指向自己的下一个节点。第二行代码就是让下一个节点的pre指向自己的上一个节点。删除操作的时间复杂度为O(1)。

添加

假设有A、C两个节点,现要往中间添加一个B节点。思路看图都能想到,你的写法不一定要和我一样,只是注意别丢失节点了,代码如下:

//写法1
public void addNode(DataNode pre,DataNode node){
    //先记录一下pre.next节点,否则下一步会丢失C节点
    DataNode next = pre.next; // 记录C
    pre.next = node; //A->B
    node.next = next; //B->C
    next.pre = node; // B<-C 
    node.pre = pre; // A<-B
}
//写法2,不用临时变量
public void addNode(DataNode pre,DataNode node){
    node.next = pre.next; //B->C
    node.pre = pre; //A<-B
    pre.next = node; // A->B
    node.next.pre = node; //C<-B
}

算法题

LRU缓存

关于链表的算法题中,我觉得最能训练链表操作的就是LRU缓存。即给出已给固定容量的容器,往里put元素时,如果容量到达最大,就删除最久未使用的元素。

题目描述:

实现 LRUCache 类:

LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存

int get(int key) 如果关键字 key 存在于缓存中,则返回关键字的值,否则返回 -1 。

void put(int key, int value) 如果关键字 key 已经存在,则变更其数据值 value ;如果不存在,则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ,则应该 逐出 最久未使用的关键字。

函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

思路:根据key找到value,所以肯定要一个Hash表存储值。元素数量超过capacity就要删除最久未使用的关键字。我们就设计一个链表,每次get元素A时,就把A移到链表头部。需要删除元素时,直接删除链表尾部的元素,尾部的就是最久没使用的。

每次get时要把对应的元素移至头部,为了避免遍历链表,设计Hash表的value类型可以设置成DataNode,这样就免去的链表查找的时间。DataNode就复用开头定义的数据结构。

class LRUCache {
    int capacity;
    HashMap map;
 
 //定义一个虚拟的头节点和尾节点,方便删除尾节点和往头节点添加元素
 DataNode head;
 DataNode tail;

 //1.初始化相关属性
 public LRUCache(int capacity) {
 this.capacity = capacity;
 map = new HashMap<>();
 head = new DataNode();
 tail = new DataNode();
 head.next = tail;
 tail.pre = head;
 }
 //2.实现get逻辑,里面的moveToHead可以先不实现
 public int get(int key) {
 DataNode node = map.get(key);
 if(node==null){
 return -1;
 }
 //把node节点移至头部
 moveToHead(node);
 return node.value;
 }
 
 //3.实现put逻辑
 public void put(int key, int value) {
 if(map.containsKey(key)){
 //如果当前key已经存在
 DataNode node = map.get(key);
 moveToHead(node);
 node.value = value;
 }else{
 //不存在就新建一个node,如果超过capacity就删除尾部节点
 DataNode node = new DataNode(key,value);
 map.put(key,node);
 if(map.size()>capacity){
 //因为还要从map中删除元素,所以removeTail要有返回值
 DataNode delNode = removeTail();
 map.remove(delNode.key);
 }
 addHead(node);
 }
 }
 
 //4.最后一步,实现上面所需的链表操作方法
 private void moveToHead(DataNode node){
 //先删除,再移至头部
 removeNode(node);
 addHead(node);
 }
 
 private void addHead(DataNode node){
 node.next = head.next;
 node.pre = head;
 head.next = node;
 node.next.pre = node;
 }
 
 private DataNode removeTail(){
 DataNode delNode = tail.pre;
 removeNode(delNode);
 return delNode;
 }
 
 //removeTail和moveToHead都有删除元素的操作,所以再提取一个删除方法
 private void removeNode(DataNode node){
 node.pre.next = node.next;
 node.next.pre = node.pre;
 }
}

反转链表

反转链表也是面试中出现频率比较高的,反转链表是个单向链表,它的操作比双向链表更简单。

题目描述:

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

思路:定义两个指针(变量),一个指向当前节点,一个指向前一个节点。每次反转指针指向的两个节点,然后指针往后移一位。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 * int val;
 * ListNode next;
 * ListNode() {}
 * ListNode(int val) { this.val = val; }
 * ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null||head.next==null){
            return head;
        }
        ListNode pre = null;
        ListNode node = head;
        while(node!=null){
            ListNode temp = node.next;
            //反转node和pre
            node.next = pre;
            //node和pre往后移一位
            pre = node;
            node = temp;
        }
        //因为node最终会移到尾节点的next上,也就是null
        //所以pre才是真正的尾节点,也就是反转后的头节点
        return pre;
    }
}

环形链表

题目描述:

出一个链表的head,判断该链表是否是环形链表。如果是,就返回环形的入口。如果不是,就返回null。

如上图,入口节点就是2。

思路1:要做出这个题不难,第一下就能想到:边遍历链表,边往Hash表存储节点,每次遍历前判断Hash表是否存在当前节点,如果存在,这个节点就是环形入口。如果遍历完了,还没有重复节点,就说明没有环形。时间复杂度:O(n),空间复杂度:O(n)。

/**
 * Definition for singly-linked list.
 * class ListNode {
 * int val;
 * ListNode next;
 * ListNode(int x) {
 * val = x;
 * next = null;
 * }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        HashSet set = new HashSet<>();
 while(head!=null){
 if(set.contains(head)){
 return head;
 }
 set.add(head);
 head = head.next;
 }
 return null;
 }
}

思路2:优化链表的空间复杂度常用手段就是用指针,思路2就是定义两个快慢指针,属于数学逻辑范畴了。我们定义一个慢指针slow,一个快指针fast。slow一次移动一位,fast一次移动两位。

  • 如果fast移到了null节点,说明链表无环,直接返回null
  • fast和slow相遇
    • 此时fast和slow一定在环形内,否则不可能相遇。我们假设head到环形入口(不含入口)的长度为x,环形长度为y。
      • 然后假设slow走了s步,则fast走了2s步(fast是slow的两倍速)
      • fast和slow相遇时,fast在环内比slow多走了ny步(关键点,可以画图理解一下)
      • 所以fast=2s=s+ny(s是slow走的步数,ny是fast比slow多走的步数)
        • 所以s=ny
    • 根据上面的推测s=ny,接着可以推算出,入口点就是x+ny。因为y是环形长度,n是正整数,所以ny实际上和y没区别,无非就是多绕了几圈。(关键点,也可以画图理解一下)。
      • 此时slow已经走了ny步,所以再走x步就是入口点了。但是我们不知道x等于多少,那我们就让一个指针从head再走一遍,一次走一步,和slow相遇点就是入口点。为了少创建一个变量,可以让fast指针回到head节点重新走。
public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head==null||head.next==null){
            return null;
        }
        ListNode slow = head;
        ListNode fast = head;
        while(true){
            if(fast == null||fast.next == null){
                return null;
            }
            slow = slow.next;
            fast = fast.next.next;
            //第一次相遇
            if(fast==slow){
                break;
            }
        }
        fast = head;
        while(fast!=slow){
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
}

总结

链表必须要掌握它的删除、添加、查找三个基础操作。链表的类型还分为:单向链表、循环链表(头尾相连,或者带环的)、双向链表。只要掌握了双向链表的基础操作,其他链表都不在话下。

关于链表的算法中,因为不能像数组那样,通过下标随机访问,所以一般会把节点存进Hash表。如果Hash表也不想存,想优化空间复杂度,一般的做法是定义指针。单向链表一般要定义双指针,一个指向当前,一个指向前一个,如果是双向链表,只用定义一个。但是在算法题中,单纯只考链表的题目比较少,很多都会带一些其他知识点。比如链表的排序、链表的二分查找等。只要熟练掌握链表的插入、删除,只用考虑排序、查找的逻辑就行了,跟数组的排序、二分查找没啥区别。

链表算法题总结 这个图是代码随想录知识星球 (opens new window)海螺人 (opens new window),所画,总结的非常好,分享给大家。考察链表的操作其实就是考察指针的操作,是面试中的常见类型。链表篇中开头介绍链表理论知识 (opens new window)关于链表,你该了解这些!虚拟头结点的技巧(opens new window)链表的增删改查(opens new window)反转一个链表(opens new window)删除倒数第N个节点(opens new window) 阅读详情

相关推荐

Java算法题

在技术笔试中,算法题主要考察对基础数据结构(数组、链表、树、栈 / 队列、图)的掌握,以及经典算法思想(动态规划、贪心、查找排序、回溯)的应用。以下按分类,整理高频笔试算法题,包含题目描述、核心思路与代码实现(以 Java/Python 为主,兼顾可读性与效率)。

haogexiaole的博客 1239

Leetcode链表题目集合

160.Intersection of Two Linked Lists 注意,链表结点相同意味着他们的值相同,下一个结点也相同 方法1:暴力法 方法2: /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode...

weixin_44137260的博客 361

UNITY3D万人同屏,Dots万人同屏解决方案_类萌宠宠之战

UNITY3D弹幕游戏开发,万人同屏解决方案

6475

[Leetcode] 高频题汇总 —— 链表

前言 链表是一种常见的线性数据结构。对于单向链表,每个节点有一个 nextnextnext 指针指向后一个节点,还有一个成员变量用以存储数值;对于双向链表,还有一个 prevprevprev 指针指向前一个节点。与数组类似,搜索链表需要 O(n)O(n)O(n) 的时间复杂度,但是链表不能通过常数时间读取第 kkk 个数据。链表的优势在于能够以较高的效率在任意位置插入或删除一个节点。 解题思路 ...

chinanfsk的博客 1867

电力市场小白必看:手把手教你用Matlab实现市场出清电价计算(附完整代码)

本文为电力市场初学者提供了使用Matlab计算市场出清电价的完整指南。通过Yalmip和Matpower工具包,详细讲解了从环境配置到模型构建、求解及结果分析的整个过程,帮助读者快速掌握节点电价计算的核心技术。

weixin_30379531的博客 74

保姆级图解:HKMG工艺中的‘覆盖层’(Cap Layer)到底怎么调阈值电压?

本文深入解析了HKMG工艺中覆盖层(Cap Layer)如何精准调控阈值电压的关键技术。通过原子级精度的ALD工艺和材料选择,覆盖层在半导体制造中扮演着隐形调节器的角色,直接影响晶体管的电气特性。文章详细介绍了La2O3和Al2O3等材料的特性对比、ALD工艺的原子级控制,以及实战调试中的关键步骤和问题排查方法。

weixin_27032989的博客 497

数据结构算法--链表高频题精讲

提纲 链表简介 面试题精讲 一些例题 例1: 链表的插入与删除 例2: 链表翻转 例3: 单链表找环及起点和环长度 例4: 复制带有随机指针的链表 例5: 链表partition过程 总结 1. 链表简介 链表: 一个元素和下一个元素靠指针连接(松散),不能O(1)直接访问到第k个元素 单(向)链表: 只能找到下一个节点 双向链表:能找到上一个和下一个节点 循环(单、双)链表:首尾相...

Galbraith_的博客 461

CYUSB3065配置CMOS

按照OG02B10的时序电路,在通过SCCB配置CMOS之前,需要三个电源上电,Xshutdown高电平和配置时钟电路。找到手册的第6章SCCB(跟IIC很像),可以看到SCCB的地址与SID引脚有关,这个需要到硬件原理图上确认下。这是Cypress的一个支持MIPI和UVC的模块,有例程支持OV5640,现在要替换替换成OG02B10。寄存器参数需要找到厂家的FAE,由他们提供,OG02B10的资料已经上传。(2)参考得宏的电路,时钟由主控提供,目前程序未实现。这里有两个重要参数需要搞定,摄像头的。

qq_40773212的博客 2949

高频面试算法题——链表

目录一、双向链表二、链表反转三、链表中倒数第k个结点四、奇偶链表五、删除排序链表中的重复元素 一、双向链表 package com.jp.yuanfudao.prepare.mianshi.test0616; import com.sun.xml.internal.ws.api.message.Header; import jdk.internal.org.objectweb.asm.tree.analysis.Value; import java.io.IOException; import jav

qq_36908783的博客 276

使用 MATLAB/Simulink 对一个开关磁阻电机进行建模

*开关磁阻电机(Switched Reluctance Motor, SRM)**是一种新型的无刷电机,以其简单的机械结构、宽广的调速范围和较高的效率在工业应用中得到了广泛关注。SRM的独特之处在于其定子和转子均为凸极结构,并且通过改变绕组电流的方向来实现转矩的产生和控制。本教程将详细介绍如何使用对一个开关磁阻电机进行建模,并探讨其基本控制策略,特别是针对双凸极结构的SRM。本文介绍了如何使用构建一个开关磁阻电机的双凸极结构模型,并探讨了其基本控制策略。

amy_mhd的博客 203

单反相机物镜设计[DG-10]

REAR(要打在像面,操作数要找像面对应位置15):以透镜单位表示的真实光线径向坐标,波长由Wave定义,参见“Hx、Hy、Px和Py”。最小玻璃厚度最小不能小于semi-dia的1/10,要根据layout看有没有过厚过薄,反复调节。PROD:两个操作数的乘积(操作#1 X操作#2)。3x4就是57.3x0.41=23.5。拦光一般在第一面和最后一面操作,减少边缘无用光线。光阑面与镜面贴近,要调距离,同时设置光阑像差。后截距是指从镜头后表面到焦点的距离。CONS:弧度转为角度。镜头相互嵌入,有错误。

weixin_72050316的博客 600

计算机408考研——线性表(Linear List)王道学习笔记

线性表:具有相同数据类型的n(n≥0)个数据元素的有限序列逻辑特征:存在唯一的第一个元素(表头)存在唯一的最后一个元素(表尾)除表头外,每个元素有且仅有一个直接前驱除表尾外,每个元素有且仅有一个直接后继选择题必考2-3题算法题10年有6年考链表操作高频考点:链表逆置、有序表合并、环检测备考建议深入理解顺序表和链表的存储差异熟练掌握头结点在链表中的作用严格训练指针操作的边界条件处理真题演练时注意时间复杂度的标注最后提醒:线性表算法题务必手写代码而非只看不练!

fengyan__的博客 875

知识图谱(Knowledge Graph)原理与代码实战案例讲解

知识图谱(Knowledge Graph)原理与代码实战案例讲解 作者:禅与计算机程序设计艺术 / Zen and the Art of Computer Programming 1. 背景介绍 1.1 问题的由来

AI天才研究院 1081

Java 栈(Stack)全面详解:从原理到面试,一篇就够了

栈是最基础的数据结构之一,掌握其原理、Java 中的推荐实现(Deque/ArrayDeque)、典型算法场景和面试高频题,是每个 Java 开发者的基本功。建议读者亲手实现一个简单的栈,并完成本文提到的几道经典算法题,做到真正融会贯通。

2501_91525818的博客 411

基于 Simulink 的飞轮储能系统(Flywheel Energy Storage System, FESS)充放电协调控制实战教程

本教程详细介绍了基于Simulink的飞轮储能系统(FESS)建模与控制方法。系统采用永磁同步电机(PMSM)和背靠背变流器架构,包含机侧全速域矢量控制和网侧直流稳压控制。重点讲解了机电耦合建模、FOC控制算法实现、基于电压下垂的协调控制策略,以及混合储能系统设计思路。教程提供了MATLAB函数代码示例,并给出典型工况下的仿真波形分析指南,同时指出了常见问题解决方案。该模型可用于研究飞轮储能在调频、能量回收等场景的应用,为新能源消纳和微网稳定提供仿真工具。

MHD0815的博客 168

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

Java 面试中的高频算法题详解

在Java面试中的高频算法题中,常见的有排序算法、动态规划、回溯算法和贪心算法等。每种算法都有其独特的应用场景和解题策略。排序算法如快速排序和归并排序广泛用于数组和列表的排序;动态规划用于解决如背包问题、最长公共子序列等需要优化子问题的复杂问题;回溯算法适用于解约束条件的排列、组合问题,例如N皇后问题;而贪心算法则在活动选择、最短路径等问题中通过局部最优选择构建全局最优解。这些算法不仅是编程面试中的常见题目,也是日常编程工作中解决复杂问题的常用工具。通过对这些算法的深入理解和掌握,可以帮助开发者提高解决问题

想看什么文章都可以私信给我,综合性博客。 2207

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

Leetcode高频算法题——字节跳动篇

众所周知,字节跳动面试非常喜欢考算法题。 Leetcode官方的企业题库不仅付费,而且题量非常大。 因此,我从20年7月开始,手动整理牛客面经涉及的Leetcode算法题,并按照频度由高到低进行了排列。以下列出的250多道高频题目。 如果你想查看按部门、岗位查看高频算法题,或者查看其他大厂的题库,可以使用我开发的CodeTop:https://codetop.cc 字节跳动题库已覆盖抖音、飞书、架构、data、商业变现、懂车帝、电商、今日头条等20多个部门。 字节跳动高频题(更新至2021年4.10日)

Erazer_Control 9000

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

链表高频算法题

//合并两个有序链表 class Solution { public: ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { if (!l1) { return l2; } if (!l2) { return l1; } ListNode* dummy = new ListNode; ListNode*

sandrew0916的博客 2795

面试高频出现的 leetcode 算法题集(重中之重)

以下列出面试高频出现,以及一些非常经典重要的算法题: 表示已完成 实战题目 - Array [11] 盛最多水的容器 [26] 删除排序数组中的重复项 [66] 加一 [70] 爬楼梯 [88] 合并两个有序数组 [189] 旋转数组 [283] 移动零 实战题目 - Linked List [21] 合并两个有序链表 [24] 两...

Seina 3万+

【大厂秋招高频算法】阿里秋招高频算法题汇总(中级篇)

这里讲一下阿里秋招中的高频算法题,分为三个部分: 基础篇 、 中级篇 、 进阶篇 目的就是为了应对秋招中的算法题,其实过算法题的诀窍就在于 理解的基础上 + 背会 看到一个题目,首先要了解题目考察的算法是什么,这个算法要理解,至于具体实现的话,就靠背会了(多写、多练),没有什么捷径!

qq_45260619的博客 1309

LeetCode算法题高频整理(精华篇)

1. 写在前面 之前刷题的时候,尝试把自己刷过的LeetCode算法题分类整理成了一个专栏算法刷题笔记,大约用14篇文章把算法题进行分类整理概括及总结,目前大约400道题目,本来想着秋招面试准备就反复刷这些就好,基本上能拿下80%的面试题。 但是发现400道量还是太多了,有很多刷过还总是忘,特别是数字找规律的那种, 并且我通过准备发现, 其实最常考和必会的并没有这么多, 面试官也是人呐, 考的肯定是他会的题目, 而太复杂的我们也都懂得哈哈。 所以这篇博客是整理在准备秋招面试刷题过程中,感觉出现的一些高频算法

Miracle8070 9748

set_map的实现+set/map加持秒杀高频算法题锻炼算法思维

文章摘要: 本文介绍了C++中set和map容器的基本用法与实现原理。set基于红黑树实现,具有排序和去重功能,增删查效率为O(logN)。通过代码示例展示了set的构造、迭代器遍历、插入、删除及查找操作,并对比了multiset允许值冗余的特性。map的insert和operator[]方法详解了其插入、修改和查找的复合功能,强调[]既能修改值又能插入新键值对的特性。最后提及count、lower_bound等实用方法,适用于区间操作。整体内容结合代码演示,适合快速掌握这两种关联容器的核心用法。

asciiletters的博客 3148

技术面试:高频算法题解析

技术面试中的高频算法题通常分为以下几类:数组与字符串、链表、树与图、动态规划、排序与搜索、贪心算法、回溯算法、位运算等。时间复杂度:平均O(n log n),最坏O(n²);空间复杂度:O(log n)。时间复杂度:O(n),空间复杂度:O(min(m, n)),其中m为字符集大小。时间复杂度:O(n),空间复杂度:O(1)(可优化为滚动数组)。时间复杂度:O(n + m),空间复杂度:O(1)。时间复杂度:O(m×n),空间复杂度:O(m×n)。时间复杂度:O(log n),空间复杂度:O(1)。

2501_94073045的博客 860

【大厂秋招高频算法】阿里秋招高频算法题汇总(进阶篇)

这里讲一下阿里秋招中的高频算法题,分为三个部分: 基础篇 、 中级篇 、 进阶篇 目的就是为了应对秋招中的算法题,其实过算法题的诀窍就在于 理解的基础上 + 背会 看到一个题目,首先要了解题目考察的算法是什么,这个算法要理解,至于具体实现的话,就靠背会了(多写、多练),没有什么捷径! 还有一点要注意的是,在大厂的比试中, 可能考察算法的方式是 ACM 模式 ,这一点和力扣上不同,ACM 模式需要我们自己去引入对应的包,以及自己写算法,力扣是将方法框架给定,只需要在方法内写代码就可以了,这一点要注意!

qq_45260619的博客 1505

【LeetCode】set和map相关算法题 前K个高频单词、随机链表的复制、两个数组的交集、环形链表

set和map相关算法题 前K个高频单词、随机链表的复制、两个数组的交集、环形链表

2501_90265152的博客 513
上一篇: 12┃音视频直播系统之 WebRTC 实现1对1直播系统实战
下一篇: Python 中的内存管理
pythonxxoo
博客等级 码龄5年 337粉丝 670原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值