单链表知识点以及实现

已于 2022-05-06 15:20:05 修改
阅读量987 收藏 7
点赞数 20
分类专栏： 数据结构初阶 文章标签： 链表 散列表 数据结构
于 2022-05-06 15:19:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ll_R_lL/article/details/124610205
版权

目录

前情回顾

1.链表

1.1 链表的概念及结构

1.2链表的实现

1.2.1如何写打印

1.2.2如何写尾插

1.2.3头插、头删

1.2.4尾删

1.2.5在pos之后插入、删除

1.3完整代码

SList.h

SList.c

Test.c

前情回顾

顺序表：数据存在一个连续的物理空间中

优势：

  1. 物理空间连续
  2. 下标的随机访问

劣势：

  1. 空间不够，需要扩容。扩容有一定性能消耗，其次一般扩容2倍，会存在一些空间浪费。
  2. 头部或者中间位置的插入删除效率低下（只有尾插尾删效率比较高）

有什么改善方式呢？

那我们就需要链表结构来进行改善。

1.链表

1.1 链表的概念及结构

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表

中的指针链接次序实现的 。

  1. 按需申请释放空间（链表可以将数据存放在单独空间中）
  2. 头部或者中间需要插入删除，不需要挪动数据

用一个指针指向第一个结点（头指针或头结点），依次往下指，遇见空指针截止

链表的是针对顺序表的劣势去设计出来的

示例一个链表的基本结构

SList.h

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int SLDataType;
struct SListNode
{
	SLDataType data;
	struct SListNode* next;//指向下一个结点的指针
};

给了四个结点，如何链接？

SList.h

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int SLDataType;
typedef struct SListNode
{
	SLDataType data;
	struct SListNode* next;//指向下一个结点的指针
}SLTNode;

Test.c

#include "SList.h"

//输入一些值，创建一个链表
void TestSList1()
{
	SLTNode* n1 = malloc(sizeof(SLTNode));
	assert(n1);

	SLTNode* n2 = malloc(sizeof(SLTNode));
	assert(n2);

	SLTNode* n3 = malloc(sizeof(SLTNode));
	assert(n3);

	SLTNode* n4 = malloc(sizeof(SLTNode));
	assert(n4);

	n1->data = 1;
	n2->data = 2;
	n3->data = 3;
	n4->data = 4;

	n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n4->next = NULL;

}

int main()
{
	TestSList1();
	return 0;
}

从图片上来看，逻辑结构：箭头只是形象的说法

代码写法：

n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n4->next = NULL;

n1……n4是结构体指针，指针存的是地址，指向的是一个结构体的地址

结构体指针通过箭头访问到next

物理结构：在内存中的存储形式的体现

第一个结点存第二个结点的地址->第二个结点存第三个结点的地址->……->第四个存NULL的地址

1.2链表的实现

以下具体分析一些部分难点

1.2.1如何写打印

SList.c

#include "SList.h"


void SListPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while ( cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;//取指向结构体中的next的值 赋值行为
	}
	printf("NULL\n");
}

next也是一个结构体中的指针

结构体的指针赋给结构体的指针

1.2.2如何写尾插

plist是一个实参，phead是一个形参

形参的改变不会影响实参

传地址解引用过去才能改变它

指针传参例子：

void f1(int a)
{
	a = 1;
}

int main()
{
//	TestSList2();
	
	int x = 0;
	f1(x);
	printf("%d\n", x);//0
	
	return 0;
}

void f1(int* p)
{
	*p = 1;
}

int main()
{
//	TestSList2();
	
	int x = 0;
	f1(&x);
	printf("%d\n", x);//1
	
	return 0;
}

注意：使用地址时光传值是不会发生变化的

void f2(int* p)
{
	int* px = (int*)malloc(sizeof(int));
	assert(px);
	p = px;
}

int main()
{
//	TestSList2();

	int* ptr = NULL;
	f2(ptr);
	printf("%p\n", ptr);//00000000

	return 0;
}

void f2(int** pp)
{
	int* px = (int*)malloc(sizeof(int));
	assert(px);
	*pp = px;
}

int main()
{
//	TestSList2();

	int* ptr = NULL;
	f2(&ptr);
	printf("%p\n", ptr);//007B4CE0

	return 0;
}

说明：要改变int，传int的地址，解引用改变

要改变int*，传int*的地址，解引用改变（指针的地址就是二级指针）

正确写法：

SList.c

void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	//要让上一个结点存新插入这个结点的地址才是尾插
	//新结点要存NULL
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	assert(newnode);
	newnode->data = x;
	newnode->next = NULL;

	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
    //找尾结点（尾结点的特征是NULL）
	SLTNode* tail = *pphead;
	while (tail->next != NULL)
	{
		tail = tail->next;
	}

	tail->next = newnode;//改变的是结构体，使tail里面的next指针指向newnode
	}
}

注意：改变plist的要使用二级指针

1.2.3头插、头删

链表只有一个结点的时候也可以删，删成空

但接着再删就有问题了。解决这种问题要使用空指针检查

温柔if或者暴力assert

小tips：断言在debug版本下才有用，release上断言会被忽略

1.2.4尾删

void SListPopBack(SLTNode** pphead)
{
	assert(*pphead);

	//1.只有一个结点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	//2.有多个结点
	else
	{
		//法1
		/*SLTNode* tailPrev = NULL;
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
		tailPrev = tail;
		tail = tail->next;
		}
		free(tail);
		tailPrev->next = NULL;*/

		//法2
		SLTNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

一定不能为空的时候，要进行断言检查啊（检查的都是指针）

  • 1.所有用二级指针的地方
  • 2.具体情况具体分析

1.2.5在pos之后插入、删除

这里让pos指向newnode相当于pos重新指向一个新位置，与原链表之间断开，断开之后找不到d2

然后下一行代码相当于new弄得自己指向自己，找不到d2

注意顺序！

正确写法：

void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);

	SLTNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;

}

不在意顺序的写法：

void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);

	SLTNode* newnode = BuySListNode(x);
	SLTNode* next = pos->next;

	pos->next = newnode;
	newnode->next = next;
}

1.3完整代码

SList.h

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;//指向下一个结点的指针
}SLTNode;

SLTNode* BuySListNode(SLTDataType x);

//打印
void SListPrint(SLTNode* phead);

//尾插
void SListPushBack(SLTNode** pphead, SLTDataType x);

//头插
void SListPushFront(SLTNode** pphead, SLTDataType x);

//尾删
void SListPopBack(SLTNode** pphead);

//头删
void SListPopFront(SLTNode** pphead);

//查找(附带修改
SLTNode* SListFind(SLTNode* phead, SLTDataType x);

// 在pos位置之前插入
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);

// 删除pos位置的值
void SListErase(SLTNode** pphead, SLTNode* pos);

//在pos之后插入
void SListInsertAfter(SLTNode* pos, SLTDataType x);

//单链表删除pos位置之后的值
void SListEraseAfter(SLTNode* pos);

SList.c

#include "SList.h"


void SListPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while ( cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;//取指向结构体中的next的值 赋值行为
	}
	printf("NULL\n");
}

SLTNode* BuySListNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	assert(newnode);
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	//要让上一个结点存新插入这个结点的地址才是尾插
	//新结点要存NULL
	SLTNode* newnode = BuySListNode(x);

	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
    //找尾结点（尾结点的特征是NULL）
	SLTNode* tail = *pphead;
	while (tail->next != NULL)
	{
		tail = tail->next;
	}

	tail->next = newnode;//改变的是结构体，使tail里面的next指针指向newnode
	}
}

void SListPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

	SLTNode* newnode = BuySListNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);

	//1.只有一个结点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	//2.有多个结点
	else
	{
		//法1
		/*SLTNode* tailPrev = NULL;
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
		tailPrev = tail;
		tail = tail->next;
		}
		free(tail);
		tailPrev->next = NULL;*/

		//法2
		SLTNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}


void SListPopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead != NULL);
	/*if (*pphead == NULL)
		return;*/
	//先把下一个结点用next保存起来再使用free，然后再指向下一个结点
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;

}


SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
			return cur;

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

void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pos);
	assert(pphead);

	// 头插
	if (pos == *pphead)
	{
		SListPushFront(pphead, x);
	}
	//不是头插，需要找到pos位置的前一个位置(不擅长）
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)//此处prev一定不为空
		{
			prev = prev->next;
		}
		SLTNode* newnode = BuySListNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}


void SListErase(SLTNode** pphead, SLTNode* pos)
{
	//删除数据，还得知道前一个的位置
	assert(pphead);
	assert(pos);//不用考虑链表为空到状态

	//头删
	if (*pphead == pos)
	{
		SListPopFront(pphead);
	}
	else
	{
		//pos找到前一个
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		//pos = NULL;//几乎没有效果
		//pos是形参，置空是为了防止野指针问题
	}
}

void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);

	//SLTNode* newnode = BuySListNode(x);
	//newnode->next = pos->next;
	//pos->next = newnode;

	SLTNode* newnode = BuySListNode(x);
	SLTNode* next = pos->next;

	pos->next = newnode;
	newnode->next = next;
}

void SListEraseAfter(SLTNode* pos)
{
	assert(pos);

	if (pos->next == NULL)
		return;
//	pos->next = pos->next->next;//存在结点没有释放掉的问题

	SLTNode* del = pos->next;
	//pos->next = pos->next->next;
	pos->next = del->next;
	free(del);
	del = NULL;//可写可无，但是是个好习惯
}

Test.c

#include "SList.h"

//输入一些值，创建一个链表
void TestSList1()
{
	SLTNode* n1 = malloc(sizeof(SLTNode));
	assert(n1);

	SLTNode* n2 = malloc(sizeof(SLTNode));
	assert(n2);

	SLTNode* n3 = malloc(sizeof(SLTNode));
	assert(n3);

	SLTNode* n4 = malloc(sizeof(SLTNode));
	assert(n4);

	n1->data = 1;
	n2->data = 2;
	n3->data = 3;
	n4->data = 4;

	n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n4->next = NULL;

	SLTNode* plist = n1;
	SListPrint(plist);

	SListPushBack(&plist, 5);
	SListPushBack(&plist, 6);
	SListPushBack(&plist, 7);
	SListPushBack(&plist, 8);

	SListPrint(plist);
}

void TestSList2()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPushBack(&plist, 5);
	SListPushBack(&plist, 6);
	SListPushBack(&plist, 7);
	SListPrint(plist);

	SListPushFront(&plist, 0);
	SListPrint(plist);
}

void f1(int* p)
{
	*p = 1;
}

//void f2(int* p)
//{
//	int* px = (int*)malloc(sizeof(int));
//	assert(px);
//	p = px;
//}

void f2(int** pp)
{
	int* px = (int*)malloc(sizeof(int));
	assert(px);
	*pp = px;
}

void TestSList3()
{
	SLTNode* plist = NULL;
	SListPushFront(&plist, 0);
	SListPushFront(&plist, 1);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 3);
	SListPushFront(&plist, 4);
	SListPrint(plist);

	SListPopFront(&plist);
	SListPopFront(&plist);
	SListPopFront(&plist);
	SListPopFront(&plist);
	SListPopFront(&plist);
	//SListPopFront(&plist);
	SListPrint(plist);
}

void TestSList4()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);

	SListPrint(plist);

	SListPopBack(&plist);
	SListPrint(plist);

	SListPopBack(&plist);
	SListPrint(plist);

	SListPopBack(&plist);
	SListPrint(plist);

	SListPopBack(&plist);
	SListPrint(plist);

	//SListPopBack(&plist);
	//SListPrint(plist);
}

void TestSList5()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPrint(plist);

	SLTNode* ret = SListFind(plist, 3);
	if (ret)
	{
		printf("找到了\n");
		ret->data = 3;
	}
	SListPrint(plist);


	SLTNode* pos = SListFind(plist, 3);
	if (pos)
	{
		SListErase(&plist, pos);
	}
	SListPrint(plist);
}

int main()
{
	TestSList5();

	//int* ptr = NULL;
	//f2(&ptr);
	//printf("%p\n", ptr);//007B4CE0

	return 0;
}

这里也可以给单链表添加一个菜单，自行添加即可，这里就不多加赘述。

Hey pear!
关注
专栏目录
单链表知识点图文详解
xiongIT的博客
03-19 793
单链表知识点图文详解,包括单链表的定义、初始化、按照查找运算、求长度运算、插入运算、删除元素运算
单链表基础知识整理
TENET_T的博客
09-13 1033
单链表知识整理 基础：顺序存储结构与链式存储结构 删除链表结点 链表反转 快慢指针法解决链表相关问题 顺序存储结构与链式存储结构 （首先需要理解线性表的概念） 顺序存储结构 链式存储结构 用一段连续的存储单元存放线性表的数据元素，即逻辑上相邻的，空间上也相邻。 用一组任意的存储单元存放线性表的数据元素，即逻辑上相邻的，空间上不一定相邻。 需要预分配存储空间 不需要预分配存储空间 ...
C++单链表的设计与实现
weixin_34295316的博客
03-02 203
单链表是一种常见的数据结构，c++不同于C的语言特性是封装、继承和多态。若要实现单链表，首先我们要明确什么是单链表，链表是由一个或多个节点构成的，实现链表的数据结构，我们首先是要明确的是什么是节点。节点是由数据+该节点类型的指针组成的，如下：classSeqNode { public: friendclassSeqList;//定义友元类，使链表类能够...
单链表的知识点
weixin_30553777的博客
08-31 220
看完剑指offer和编程之美，将单链表的知识点总结如下： 单链表所能遇到的知识： 单链表节点的插入和删除 判断单链表是否有环 判断两个链表是否相交 如何快速找到链表的中间节点或1/n节点 所能组成的问题： 　　说明：链表的结构体为： 1 typedef struct ListNode_{ 2 int val; 3 struct ListNode_...
单链表知识点总结
weixin_47651920的博客
10-27 1894
一.什么是链表 1.概念 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。 逻辑上连续是我们想象的连续，并不是真正的连续。 2.链表的分类 单向双向，带头结点不带头结点，循环非循环，组合起来共有8种 二.单链表及单链表的实现 这里我们只实现单链表中的增删改查和其他一些基本的方法，如果单链表弄清了，其他来链表只不过是单链表的延伸。 1.单链表的结构示意图 这里以值域为整形为例，在实际中，值域可以为任意类型 2.图解结点的增删改查 （1）插.
单链表简单实现
南猿北者博客
10-31 2384
单链表逻辑图：单链表同顺序表一样，都是线性表，除了首尾节点之外，任何一个节点都有自己的前驱和后继；但是单链表每个节点在物理上的地址是不连续的或者说是随机的，也就是说单链表的节点是要一个就开一个，不会过多的开辟空间；这一点正是弥补了顺序表的不足；从上面的逻辑图我们就可以看出，每个节点的类型应该是一样的，节点主要分为数据域和指针域，同时对于一串链表来所，最后一个节点的指针域一定是NULL，以此来标记这是链表的结尾；同时我们只需要知道单链表的头节点，就可以很好的管理整个链表；
【数据结构-D】链表之单链表知识点梳理
weixin_44768184的博客
05-13 1583
【链表】 什么是链表？ 链表是一种用于存储数据集合的数据结构，链表有以下属性： 相连的元素之间通过指针进行链接 最后一个元素的后继指针为NULL 在执行的过程中链表的长度可以增加或者是减少 链表的空间可以按需要进行分配 没有存储空间的浪费，但是链表中的指针需要额外的内存开销 1、我们常见的链表有以下种类 1）单链表、双向链表 2）不带头单链表、带头链表 3）单链表、循环单...
C++使用模板实现单链表（类外实现）
08-26
本文主要介绍了使用C++模板实现单链表的相关知识点，包括类外实现的单链表的设计、实现和应用。 首先，单链表是一种常用的数据结构，它是一种链式结构，通过指针将各个节点连接起来，每个节点都包含一个指针，指向...
单链表逆置的完整实现java版
最新发布
09-20
#### 知识点概述 本文将详细介绍如何在Java中实现单链表的逆置操作，并通过一个实际的代码示例来展示整个过程。逆置单链表是一项常见的数据结构操作，在很多算法问题中都会遇到，特别是在面试场景中更是频繁出现。...
单链表的各种操作实现
03-17
#### 知识点概览 本文将详细介绍单链表的基本概念，并基于给定的代码示例，深入探讨单链表的多种操作方法，包括但不限于插入、查找（按值和按位置）、逆置以及删除等。 #### 单链表的概念与结构 单链表是一种线性...
实验报告1.3单链表的设计与实现
12-25
实验报告1.3单链表的设计与实现 实现单链表的基本操作，包括单链表的建立与释放、查找、求长度、查找后继、插入、删除、输出等函数。
用C语言实现单链表的各种操作(一)
12-25
首先，是单链表的各种实现，其中，包含了一些常考的知识点。例如，单链表的逆置，单链表的合并，找到单链表的中间节点等的算法实现。下面这个是单链表的结构体的定义： 代码如下:typedef struct LNode{ ElemType ...
单链表相关操作和相关知识点
qq_35689566的博客
07-23 223
熟悉什么是链表，链表的分类？ 熟悉链表带头结点和不带头结点的区别？ (后面解释) 完成单链表的以下基本操作： typedef int SDataType; // 链表的节点 typedef struct SListNode { SDataType _data; struct SListNode* _pNext; }Node, *PNode; // 链表的结构，给一个头指针保存链表第一个节点的地...
链表知识点（四）【单链表排序（冒泡排序）】
u012512762的专栏
10-18 651
Link* Sort_link(Link * Head) {     Link *p;        int n;        int temp;        int i;        int j;            p = Head;        n = Calculate_Length(Head);          if(Head== NULL || He
【数据结构】单链表及其相关知识点（含代码）
qq_45806146的博客
07-16 1027
  大家好，我是A导，数据结构系列早在今年二月份我就想着每一章节都出一篇博客介绍《数据结构》相关的知识点和相关代码，之前也干过这件事，后来因为其他种种原因（其实就是我懒）没有更新下来，好不容易到暑假，我准备改过自新，开始更新博客。 开篇 在我们刚学习数据结构这门学科时，最先遇到的就是单链表这个知识，这是最基础的链式存储结构，单链表如果学的迷迷糊糊，那下面的树还有串的学习将十分困难。 下面我们就从单链表开始讲起（文章最后会给出测试代码） 首先，先上一张思维导图，了解单链表需要掌握的操作 1.创建 废话不所说
链表知识点（一）【单链表的创建操作】
u012512762的专栏
10-16 576
【单链表的创建操作】 typedef  struct lnode {        int  data;        structlnode  *next; }Lnode,*PLnode; typedef int datatype; typedef struct link {        int data;     struct link* next; }Li
单链表的设计与实现
qq_43510083的博客
05-12 1366
1、单链表的设计（linklist.h）：设计头文件linklist.h，其内容如下： ①类型设计 ②基本操作的设计（包括初始化、单链表的创建、插入、删除、遍历等） 2、设计文件c.h，提供比较和遍历时的操作函数 3、测试：设计测试文件application.cpp文件，验证所设计的顺序表的正确性。其内容如下： 设计一个主函数。 4、利用上面设计的单链表，实现下列应用 ①设计函数，删除链表中元素在[x, y]之间的所有元素，要求算法的时间复杂度为O(n)，空间复杂度为O(1)； ②设计函数，求解单链表中倒数
C++编程：静态单链表实现与操作
以下是对标题和描述中涉及的知识点的详细解释： 首先，`Node` 类定义了链表的节点结构，包含两个成员： 1. `int data`: 用于存储数据的整型变量。 2. `int cur`: 用于存储下一个节点在数组中的索引，模拟链表的指针...
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Hey pear!

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

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

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

打赏作者

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

抵扣说明：

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

余额充值