合并两个有序链表(java)

两个有序链表合并为一个有序链表(Java实现) 解题思路: 以升序为例 第一步当然是判空 如果其中一个链表为空 则返回另一个链表即可 要有序 所以需要比较结点大小 创建两个引用指向两个链表 同时分别创建将要合成链表的头和尾 比较两个结点的大小 将较小的结点 cur 放到新的链表尾部 此时要考虑特殊情况 当新链表为空时 要把头和尾都设置成 cur同时 cur 向后移 新链表不为空时将 cur放到尾部 同时 n... 阅读详情

题目:

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

输入:l1 = [1,2,4], l2 = [1,3,4]
输出:[1,1,2,3,4,4]

1、# 自定义链表类;

重写toString方法,便于观察链表数据(可有可无); 

/**
自定义链表类
*/

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; }

        @Override
        public String toString() {
                StringBuilder sb=new StringBuilder();
                ListNode next=null;
                sb.append("[");
                sb.append(val);
                next=this.next;
                while (next !=null){
                sb.append(",");
                sb.append(next.val);
                next=next.next;
                }
                sb.append("]");
                return sb.toString();
        }

}

 2、# 实现方法

public class Solution21 {


    public static ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        //l1链表为空,则输出l2,否则输出l1
        if (l1 == null) {
            return l2;
        } else if (l2 == null) {
            return l1;
 //如果l1,l2不为空,则比较首节点值的大小,如果l1小则l1.next->(mergeTwoLists(l1.next,l2))
        } else if (l1.val < l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
//反之则l2.next->(mergeTwoLists(l1,l2.next))
        } else {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }

    public static void main(String[] args) {

        ListNode l1=new ListNode(1);
        ListNode nextNode1=new ListNode(2);
        ListNode nextNode2=new ListNode(3);
        l1.next=nextNode1;
        nextNode1.next=nextNode2;

        ListNode l2=new ListNode(1);
        ListNode nextNode3=new ListNode(3);
        ListNode nextNode4=new ListNode(4);
        l2.next=nextNode3;
        nextNode3.next=nextNode4;


        System.out.println(mergeTwoLists(l1,l2));
    }
}

3、#图解

[1,2,3]                 [1,3,4]       

1<1  false   

[1,2,3]                  [3,4]        第1次递归     l2.next = mergeTwoLists(l1, l2.next);

1<3      true     

[2,3]           [3,4]                 第2次递归    l1.next = mergeTwoLists(l1.next, l2);

2<3     true

[3]           [3,4]                    第3次递归    l1.next = mergeTwoLists(l1.next, l2);

3<3     false                     

[3]          [4]                      第4次递归     l2.next = mergeTwoLists(l1, l2.next);

3<4    true

null        [4]                      第5次递归    l1.next = mergeTwoLists(l1.next, l2);

l1=null   return l2           程序结束

return   [4]                      返回 4

return  l1  [3,4]              返回第5次递归结果

return l2  [3,3,4]            返回第4次递归结果

return  l1 [2,3,3,4]         返回第3次递归结果

retruen l1 [1,2,3,3,4]         返回第2次递归结果

return  l2 [1,1,2,3,3,4]         返回第1次递归结果

   

Java算法--合并两个有序链表 题目: 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 解答: 方法1:递归 class Solution { public ListNode mergeTwoLists(ListNode... 阅读详情

相关推荐

Java有序链表合并

链表是一种常见的数据结构,它由一系列节点组成,每个节点包含一个数据元素和指向下一个节点的引用。通过比较节点的值,我们可以逐个将节点接入合并后的链表,最终得到一个有序的链表。我们通过比较两个链表当前节点的值,将较小的节点接入合并后的链表,并将对应的指针后移。本文将介绍如何合并两个有序链表,即将两个有序链表按照顺序合并成一个新的有序链表。该方法接受两个有序链表的头节点作为参数,并返回合并后的有序链表的头节点。通过上述代码,我们成功实现了将两个有序链表合并成一个新的有序链表的功能。首先,我们定义一个链表节点类。

2301_79365003的博客 230

Java链表-合并两个有序链表

定义一个新链表,定义一个新链表的指针tempNode。当合并的两个链表的头节点指针都不指向空时,比较两个链表节点的值,找到里面较小的值的地址。让新链表的指针tempNode下一个节点指向该最小值的地址,然后让该较小值的地址头指针指向下个地址。当一个链表的头指针指向空时,把另一个链表剩下的地址都填到新链表后边。这样链表就合并成功。...

m0_52012606的博客 4419

合并两个有序链表的算法实现(Java)

当我们有两个已排序的链表时,我们可能需要将它们合并成一个新的有序链表。在每次迭代中,我们比较两个链表当前节点的值,并将较小的节点连接到新链表的末尾。通过这个算法,我们可以高效地将两个有序链表合并为一个新链表。接下来,我们创建一个虚拟头节点(dummy head),它将作为新链表的头节点。在这个测试用例中,我们创建了两个有序链表(l1和l2),然后使用我们的合并函数将它们合并。最后,我们遍历新链表,并打印出它的值。在这里,我们创建了一个简单的链表节点类,它包含一个整数值和一个指向下一个节点的指针。

PixelCoder的博客 283

合并两个有序链表(Java)

解题思路: 第一步:先设置一个虚拟节点(傀儡节点) 图解: 完整代码如下:

m0_63036262的博客 5659

基于BFQ19S的共射振荡器设计(克拉泼电容三点式)

根据理论,设计出如下LC振荡器: 一、设计初期是使用= 400Mhz作为目标值计算的, 但由于计算值与实际值有差别,所以使用计算值附近的元器件代替使用;最终该电路的L1=82nH , D1 = 5.6pF, C11=18pF, C12 = 18pF ; 另外R3= 600Ω, R4取27k , C9取10pF; 该电路实际的震荡频率为主要为L1,D1 决定,所以其震荡频率约为 == 235Mhz; 二、由于实际得到的频率比目标频率低太多,所以调整电路使其能达到400M左...

rzchong1988的专栏 3705

一文搞懂深度学习:最全神经网络介绍

本文是深度学习系列文章的第二篇,我们将深入探讨各种类型的人工神经网络,探索它们独特的特性和应用。

2402_82802238的博客 2800

JAVA 将两个有序链表合并为一个有序链表

将两个有序链表合并为一个有序链表 思路: 1.必须保证两个链表为有序链表 2.在两个链表都不为空的条件下,设一个 last=null; (1)如果链表1的值小于等于链表2的值,进行循环,先放链表1的值到新链表result,如果result为空,视为头插,如果不为空,视为尾插,其中要保证last永远为最后一个结点,最后让循环走起来 (2)如果链表2的值小于链表1的值,与(1)中方法相同,只是链表1全换为链表2即可 3.如果链表2为空了,链表1不为空时,把链表1接在last的下一个,之后,可以.

Sundy_sc的专栏 2486

从.bib到.bbl:手把手教你搞定LaTeX参考文献的完整流程

本文详细介绍了从.bib到.bbl的LaTeX参考文献处理完整流程,包括文献数据库构建、样式选择、主文档配置、编译流程及问题排查。特别针对.bib、.bbl等文件的操作提供了实战解决方案,帮助用户高效管理学术文献引用,适用于各类学术写作场景。

weixin_29292431的博客 285

合并两个有序链表 java_合并两个有序链表

合并两个有序链表No more than a platitudeMerge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.Example:Input: 1->2->...

weixin_39565777的博客 139

ESP32驱动Xbox Series X手柄的BLE协议实现

蓝牙低功耗(BLE)是嵌入式设备无线交互的核心技术,其GATT协议架构支持自定义服务与特征值通信,广泛应用于游戏外设、工业遥控等场景。Xbox Series X手柄采用非标准私有BLE协议,需深度解析输入报告(64字节)、输出控制(振动/LED)及固件兼容性约束。该方案依托ESP32平台与NimBLE 2.1.0+协议栈,解决MTU协商、PHY配置与HCI事件同步等关键问题,实现125Hz实时输入采集与毫秒级振动反馈。适用于机器人遥操作、ROS2终端、LVGL交互界面等工程实践,是私有BLE设备逆向集成的典

weixin_42610671的博客 710

每日算法讲解(十):使用BP神经网络进行回归任务

BP神经网络是由输入层、隐藏层和输出层组成的多层前馈神经网络,通过反向传播算法(Backpropagation)来调整网络权重和偏置,以最小化预测误差。前向传播:将输入数据通过网络,计算每层的激活值和输出。计算误差:根据预测值和真实值之间的差异计算损失函数值。反向传播:从输出层开始,逐层向后计算梯度,并更新每层的权重和偏置。重复迭代:通过多次迭代,逐步减小预测误差,优化模型参数。接下来,我们定义一个包含一个输入层、两个隐藏层和一个输出层的BP神经网络模型。# 定义模型# 编译模型。

rhtee的博客 1726

Java合并两个有序链表,轻松掌握!

你是否曾为如何高效地合并两个有序链表而烦恼?在编程中,链表是一种常见的数据结构,但合并两个有序链表却是一个挑战。今天,我将为你揭示一个简单而高效的解决方案,让你轻松掌握这一技巧!

Q2024107的博客 534

傅里叶变换实战:用Python手把手教你分析音频频谱(附完整代码)

本文详细介绍了如何使用Python实现傅里叶变换进行音频频谱分析,涵盖音频加载、预处理、FFT应用、频谱可视化及特征提取等关键步骤。通过实战案例和完整代码,帮助开发者掌握数字信号处理技术,特别适合音频分析和音乐信息检索领域的应用。

weixin_29090677的博客 150

【Java实现】合并两个有序链表

数据结构,面试必刷合并两个有序链表

威威的博客 1836

BERTopic模型入门教程(附代码+参数调节)

BERTopic 是一种用于从文本数据中提取主题模型的新型方法。通过结合 BERT嵌入和传统的主题模型来生成语义丰富的主题。传统的主题模型(如LDA)主要依赖于词频矩阵,而 BERTopic 通过预训练语言模型生成高维语义嵌入来捕捉词语间的复杂关系,因此可以更好地处理上下文信息。BERTopic模型可以看作是创建其主题表示的一系列步骤。核心原理如下:就本质而言,BERTopic就是一个拼装框架,可以把每部分都替换成其他模型,只要完成任务即可。

m0_52069102的博客 1万+

(4-2)A*

实际已经花费的代价(g(n)):从起点到当前节点n的实际路径代价。启发式估计的剩余代价(h(n)):从当前节点n到目标节点的估计路径代价。这是A算法的关键之一,启发式函数要足够接近实际代价,但又要高效计算。如果启发式函数等于0,A算法就相当于Dijkstra算法。实现A*算法的核心步骤如下所示。(1)初始化:将起点加入开放列表(open list),并将其f值设为g值和h值的和。(2)循环:从开放列表中选择具有最小f值的节点作为当前节点。如果当前节点是目标节点,算法结束;

码农三叔 1807

合并有序链表(Java)

基于两个有序的链表融合成一个新的有序链表,首先了解链表的基本操作: Java实现双向链表结构 (1)思路分析: 既然是两条有序合并为一条,那么肯定要进行比较大小。 那么我们就以第一条有序链表(A)为基础,循环拿另外一条(B)每个元素去比较大小,插入到合适的位置。 如果B的元素小于A最前面的元素,则插入到A的最前面。 如果B从某个元素开始比A的全部元素都大,又因为B是有序链表,这个就简单了,直接把B拼接到A的尾巴即可,无需再一个个比较。 PS: 由于链表有头尾两节点,在内存中属于分散存储,所以设置好头尾下一.

whiteBearClimb的博客 640

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

java两个有序链表合并

                                       java两个有序链表合并  今天做了个算法题,遇到了点问题。和大家分享一下 要求是实现两个链表的合并。这个链表可以自己用类实现,也可以用LinkedList。为了方便访问,我用了后者实现。 看一下代码: package MM; import java.util.LinkedList; public clas...

0bug0warning的博客 400

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

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

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

【Java】剑指Offer——合并两个有序链表

1、思路概述: 首先要明确的是当我们合并完两个有序链表后,新的链表也依旧还是要有序。所以,我们首先要定义两个指针分别对两个链表进行遍历,再定义一个指针从空开始存储两个链表中挑选出来的数字。当一个链表为空时,将剩下的一个链表全部输入即可。 2、代码实现: public void merge(Link<T> link){ Link<T> link1=new Link<&g...

weixin_44836685的博客 376

IMSL CNL 7.0.0 (x86-64)Crack

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

LeetCode 21. 合并两个有序链表 java

LeetCode 21. 合并两个有序链表 java 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 : 输入:1-&gt;2-&gt;4, 1-&gt;3-&gt;4 输出:1-&gt;1-&gt;2-&gt;3-&gt;4-&gt;4 JAVA 代码: class Solution { public ListNode mergeTw...

lele的专栏 520

力扣练手21 合并两个有序链表 java版

题目描述 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 原代码: /** * Definition for singly-linked list. * public class ListNode { * ...

minyunfei6的博客 312

Java-合并有序链表

题目描述 将两个有序的链表合并为一个新链表,要求新的链表是通过拼接两个链表的节点来生成的。 1->2->3 2->3->4->5 合并结果: 1->2->2->3 >3 >4->5 import java.util.*; /* * public class ListNode { * int val; * ListNode next = null; * } */ public class Solutio.

luzhensmart的专栏 291

数据结构——将两个有序链表合并为一个新的有序链表并返回。(基于Java语言实现)

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 思想: 从两个有序链表的第一个结点开始比较,val值小的结点尾插入结果链表。 具体实现: 定义变量 (1)定义变量 cur1,cur2 分别表示两个链表; (2...

范玖久的博客 2474
上一篇: Java中的多态是如何执行的
下一篇: easypoi中文文件名导出报错已解决
小亮学java
博客等级 码龄7年 175粉丝 41原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值