几种常见的排序方法

于 2020-03-16 23:42:25 发布
阅读量234 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46507318/article/details/104870917
版权

几种排序算法的比较(时间为java的测试时间)：
在这里插入图片描述
接下来是思路和代码(java和C语言）~~~~

1.冒泡排序
思路：将第一个数和第二个数进行比较，再将第二个和第三个进行比较，依次类推，最大的数在这一组数的最末端；然后在进行该过程，将第一个数和第二个数进行比较······得到第二大的数在这一组数的倒数第二个位置······直到这一组数中最小的数在这一组数的第一个位置，排序完成。冒泡排序要进行双重循环，时间复杂度为O(n^2) ，具有稳定性

Java：

public class MaoPao {
	public static void main(String[] args) {
		int[] arr = new int[] { 12, 2, 35, 57, 34, 67, 45 };
		arr = method(arr);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
	}

	public static int[] method(int[] arr) {
		int temp = 0;
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length - 1; j++) {
				if (arr[j] > arr[j + 1]) {
					temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
		return arr;
	}
}

C语言：

#include<stdio.h>
void sort(int arr[],int n)
{
	int i,j,temp;
	for(i=0;i<n;i++)
	{
		for(j=0;j<n-i-1;j++)
		{
			if(arr[j]>arr[j+1])
			{
				temp=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=temp;
			}
		}
	}
} 
int main()
{
	int i=0;
	int arr[]={12, 2, 35, 57, 34, 67, 45};
	sort(arr,7);
	for (i = 0; i < 7; i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n");
}

2.归并排序
思路：先把数据进行分离，然后将相邻的两个数进行排序后放在数组中，接着将相邻的两个数组进行排序，直到所有数都排完。时间复杂度为O(nlog n)，具有稳定性。
Java：

public class GuiBing {

	public int[] sort(int[] arr) {
		return sort(arr,0,arr.length-1);
	}
	
	public int[] sort(int[] arr,int start,int end) {
		if(start<end) {
			int mid=(end+start)/2;
			int[] left=sort(arr,start,mid);
			int[] right=sort(arr,mid+1,end);
			return merge(left,right);
		}
		else
			return new int[] {arr[start]};
	}
	
	//将两个数组中的元素进行排序并合并在同一数组中。
	public int[] merge(int[] arr1,int[] arr2) {
		int and[]=new int[arr1.length+arr2.length];
		int i=0,j=0,t=0;
		while(i<arr1.length && j<arr2.length) {
			if(arr1[i]<=arr2[j]) {
				and[t++]=arr1[i++];
			}
			else
				and[t++]=arr2[j++];
		}
		while(i<arr1.length) {
			and[t++]=arr1[i++];
		}
		while(j<arr2.length) {
			and[t++]=arr2[j++];
		}
		return and;
	}
	
	public static void main(String[] args) {
		GuiBing a=new GuiBing();
		int[] arr = new int[] { 12, 2, 35, 57, 34, 67, 45 };
		arr = a.sort(arr);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
	}
}

C语言：

#include<stdio.h>
void sort(int arr[],int sum[],int start,int end)
{
	if(start<end)
	{
		int mid=(end+start)/2;
		sort(arr,sum,start,mid);
		sort(arr,sum,mid+1,end);
		int i=start,j=mid+1,k=start;
		int t=0;
		while(i<=mid && j<=end)
		{
			if(arr[i]<=arr[j])
			{
				sum[k++]=arr[i++];
			}
			else
				sum[k++]=arr[j++];
		}
		while(i<=mid)
		{
			sum[k++]=arr[i++];
		}
		while(j<=end)
		{
			sum[k++]=arr[j++];
		}
		for(t=start;t<=end;t++)
		{
			arr[t]=sum[t];
		}
	}
	return;
}

int main()
{
	int i=0;
	int arr[]={12, 2, 35, 57, 34, 67, 45};
	int sum[8];
	sort(arr,sum,0,6);
	for (i = 0; i < 7; i++)
	{
		printf("%d ",sum[i]);
	}
	printf("\n");
}

3.选择排序
思路：一个数组，将里面的数和排在它之后的每个数进行比较，若比后面的数大，则交换位置。时间复杂度为O(n^2)；不具有稳定性。
Java：

public class ChooseSort {
	public int[] chooseSort(int[] arr) {
		int temp;
		for(int i=0;i<arr.length;i++) {
			for(int j=i+1;j<arr.length;j++) {
				if(arr[i]>arr[j]) {
					temp=arr[i];
					arr[i]=arr[j];
					arr[j]=temp;
				}
			}
		}
		return arr;
	}
	
	public static void main(String[] args) {
		ChooseSort a=new ChooseSort();
		int[] arr = new int[] { 12, 2, 35, 57, 34, 67, 45 };
		arr = a.chooseSort(arr);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
	}
}

C语言：

#include<stdio.h>
void sort(int arr[],int n)
{
	int i,j,temp;
	for(i=0;i<n;i++)
	{
		for(j=i;j<n;j++)
		{
			if(arr[i]>arr[j])
			{
				temp=arr[i];
				arr[i]=arr[j];
				arr[j]=temp;
			}
		}
	}
} 
int main()
{
	int i=0;
	int arr[]={12, 2, 35, 57, 34, 67, 45};
	sort(arr,7);
	for (i = 0; i < 7; i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n");
}

4.插入排序
思路：将数据与前面的数据进行比较，直到遇到第一个不比它小的数，将数据插入到该数后面。适合运用在已经排好序的数列中插入新的数。时间复杂度O(n^2），具有稳定性。
Java：

public class InsertSort {
	public int[] insertSort(int[] arr) {
		int temp;
		for(int i=1;i<arr.length;i++) {
			for(int j=i;j>0;j--) {
				if(arr[j]<arr[j-1]) {
					temp=arr[j];
					arr[j]=arr[j-1];
					arr[j-1]=temp;
				}
				else
					break;
			}
		}
		return arr;
	}
	
	public static void main(String[] args) {
		InsertSort a=new InsertSort();
		int[] arr = new int[] { 12, 2, 35, 57, 34, 67, 45 };
		arr = a.insertSort(arr);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
	}
}

C语言：

#include<stdio.h>
void sort(int arr[],int len)
{
	int i,j,temp;
	for(i=1;i<=len;i++)
	{
		for(j=i;j>0;j--)
		{
			if(arr[j]<arr[j-1])
			{
				temp=arr[j];
				arr[j]=arr[j-1];
				arr[j-1]=temp;
			} 
			else
				break;
		}
	}
}
int main()
{
	int i=0;
	int arr[]={12, 2, 35, 57, 34, 67, 45};
	int sum[8];
	sort(arr,6);
	for (i = 0; i < 7; i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n");
}

5.希尔排序
思路：与插入排序有些类似，希尔排序在每一趟排序中所取数据间隔逐渐减小，最后一趟间隔为一。希尔排序时间复杂度为O(nlogn)，不稳定。
Java：

public class XiErSort {
	public int[] xier(int[] arr) {
		int n=arr.length;
		while(n>0) {
			n=n/2;
			int temp;
			for(int i=n;i<arr.length;i++) {
				for(int j=i;j>0;j--) {
					if(arr[j]<arr[j-n]) {
						temp=arr[j];
						arr[j]=arr[j-n];
						arr[j-n]=temp;
					}
					else
						break;
				}
			}
		}
		return arr;
	}
	public static void main(String[] args) {
		XiErSort a=new XiErSort();
		int[] arr = new int[] { 12, 2, 35, 57, 34, 67, 45 };
		arr = a.xier(arr);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
	}
}

C语言：

#include<stdio.h>
void sort(int arr[],int len)
{
	int i,j,temp;
	int n=len;
	while(n>0)
	{
		n=n/2; 
		for(i=n;i<=len;i++)
		{
			for(j=i;j>=n;j=j-n)
			{
				if(arr[j]<arr[j-n])
				{
					temp=arr[j];
					arr[j]=arr[j-n];
					arr[j-n]=temp;
				}
				else
					break;
			}
		}
	}
}
int main()
{
	int i=0;
	int arr[]={12, 2, 35, 57, 34, 67, 45};
	sort(arr,6);
	for (i = 0; i < 7; i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n");
}

6.堆排序
思路：建立一个完全二叉树，且保证父节点的数大于子节点的数，建立完成后，将根节点的值与最下端叶子节点交换位置，然后将叶子节点切去，再调整树节点之间的数，再进行上述过程，知道树为空。时间复杂度O(nlogn)，不稳定。
Java：

public class DuiSort {
	//交换位置
	public void swap(int[] arr,int max,int i) {
		int temp;
		temp=arr[max];
		arr[max]=arr[i];
		arr[i]=temp;
	}
	//建立完全二叉树，使父节点大于子节点
	public void duiSort(int[] arr, int n, int i) {
		int c1 = i * 2 + 1;
		int c2 = i * 2 + 2;
		int max = i;
		if (c1 < n && arr[c1] > arr[max]) {
			max = c1;
		}
		if (c2 < n && arr[c2] > arr[max]) {
			max = c2;
		}
		if(max!=i) {
			swap(arr,max,i);
			duiSort(arr,n,max);
		}
	}
	//将根节点与最小叶子节点交换位置，并切断最小叶子节点。
	public void buildHead(int[] arr,int n) {
		int lastNode=n-1;
		int parent=(lastNode-1)/2;
		for(int i=parent;i>=0;i--) {
			duiSort(arr,n,i);
		}
		swap(arr,parent,lastNode);
	}
	
	public void sort(int[] arr,int n) {
		buildHead(arr,n);
		for(int i=n-1;i>=0;i--) {
			swap(arr,0,i);
			duiSort(arr,i,0);
		}
	}

	public static void main(String[] args) {
		DuiSort a = new DuiSort();
		int[] arr = new int[] { 12, 2, 35, 57, 34, 67, 45 };
		int n = arr.length;
		a.sort(arr, n);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
	}

}

C语言：

#include<stdio.h>
//交换位置 
void swap(int arr[],int max,int min)
{
	int temp;
	temp=arr[max];
	arr[max]=arr[min];
	arr[min]=temp;
}

//建立完全二叉树，满足父节点大于子节点。
void duisort(int arr[],int n,int i)
{
	int c1=2*i+1;
	int c2=2*i+2;
	int max=i;
	if(c1<n && arr[c1]>arr[max])
	{
		max=c1;
	}
	if(c2<n && arr[c2]>arr[max])	
	{
		max=c2;
	}
	if(max!=i)
	{
		swap(arr,max,i);
		duisort(arr,n,max);
	}
} 

void  buildHead(int arr[],int n)
{
	int lastNode=n-1;
	int father=(lastNode-1)/2;
	int i;
	for(i=father;i>=0;i--)
	{
		duisort(arr,n,i);
	}
}


 
void sort(int arr[],int n)
{
	buildHead(arr,n); 
	int i;
	for(i=n-1;i>=0;i--)
	{
		swap(arr,i,0);
		duisort(arr,i,0);
	}
}

int main()
{
	int i=0;
	int arr[]={12, 2, 35, 57, 34, 67, 45};
	sort(arr,7);
	for (i = 0; i < 7; i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n");
}

7.快速排序
思路：选取基准数，将大于基准树的数放于基准数右边，小于基准数放于基准树左边，然后在左右边中再次选取基准数，重复上述过程，递归实现。时间复杂度O(nlogn)，不稳定。
Java：

public class KuaiSuSort {
	public void sort(int[] arr,int start,int end) {
		int left=start;
		int right=end-1;
		if(left>=right)
			return;
		int mid=arr[start];//基准数
		while(left<right) {
			while(left<right && arr[right]>=mid) {
				right--;
			}
			//右边小于基准数的数
			arr[left]=arr[right];
			while(left<right && arr[left]<=mid) {
				left++;
			}
			//左边大于基准数的数
			arr[right]=arr[left];
		}
		if(left==right)
			arr[left]=mid;
		sort(arr,start,left+1);
		sort(arr,left+1,end);
	}
	
	public static void main(String[] args) {
		KuaiSuSort a =new KuaiSuSort();
		int[] arr = new int[] { 45, 2, 35, 57, 34, 67, 12 };
		int n = arr.length;
		a.sort(arr, 0, n);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
	}
}

C语言：

# include<stdio.h>
void sort(int arr[],int start,int end)
{
	int left=start;
	int right=end;
	if(left>=right)
		return;
	int mid=arr[start];
	while(left<right)
	{
		while(left<right && arr[right]>=mid)
		{
			right--;
		}
		arr[left]=arr[right];
		while(left<right && arr[left]<=mid)
		{
			left++;
		}
		arr[right]=arr[left];
	} 
	if(left==right)
		arr[left]=mid;
	sort(arr,start,left);
	sort(arr,left+1,end);
} 

int main()
{
	int i=0;
	int arr[]={12, 2, 35, 57, 34, 67, 45};
	sort(arr,0,6);
	for (i = 0; i < 7; i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n");
}
foreverAC
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
快速排序算法的证明与边界分析
nwpu2015302463的博客
09-13 351
算法证明 算法证明使用算法导论里的循环不变式方法 快排模板(以j为分界) 快排属于分治算法，分治算法都有三步： 分成子问题 递归处理子问题 子问题合并 void quick_sort(int q[], int l, int r) { //递归的终止情况 if(l >= r) return; //第一步：分成子问题 int i = l - 1, j = r + 1, x = q[l + r >> 1]; while(i < j) {
几种常见的排序方式
weixin_43824601的博客
11-15 921
1、冒泡排序 冒泡排序（Bubble Sort），它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序错误就把他们交换过来。冒泡排序的时间复杂度平均情况下为O(n*2)。 /** * 冒泡排序 * @author Victor Gong * */ public class BubbleSort { public void sort(int[] a) { for (int i = 0; i < a.length; i++) { for (int j = 0; j &lt
常见的几种排序方法--javascript版
不二的博客
09-06 449
目录 1.背景介绍 2.知识剖析 3.常见问题 4.解决方案 冒泡排序 选择排序（Selection sort） 插入排序（英语：Insertion Sort） 快速排序 5.扩展思考 6.参考文献 7.更多讨论   1.背景介绍 在计算机科学与数学中，一个排序算法（英语：Sorting algorithm）是一种能将一串资料依照特定排序方式进行排列的一种算法。 最常用...
排序算法之我观
菱形继承
01-23 3869
笔者今年是xmu大一新生 9月初学编程 学到泡排的时候就对排序这一块深入了解 (也只是很粗浅地学习了一下) 写这篇文章的初衷就是复习一下之前所学，有不足之处请不吝赐教 所谓排序 就是将杂乱无章的数据变得有规律 这其中有五花八门的算法，时间复杂度相同的算法不一而足 目前笔者只给读者展示几种基础算法 (冒泡排序，选择排序，插入排序，堆排序，快速排序，基数排序，希尔排序，归并排序） 有低效但好用，高效但...
数组按照特定顺序排序问题
weixin_30641999的博客
12-11 1647
遇到数组按照特定顺序排序问题，比如查询出来的数组要按照特定的一个位置来放置时可以用到 例如：数组查询出来的为var var sortArr= ["3年","1年","2年"];，但是我们想让他an找standardArr= ["1年","2年","3年"]来排序，可以调用如下方法 sortCommon(sortArr,standardArr); function sortCommon(sor...
快速排序基本思路（通俗易懂+例子）
热门推荐
code_AC的博客
07-02 29万+
快速排序今天看到大神写的一篇快速排序的博客，肃然起敬，觉得原来快速排序这么简单 下面进行简单的试试快速排序的基本思想是 1、先从数列中取出一个数作为基准数 2、分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边 3、再对左右区间重复第二步，直到各区间只有一个数 概括来说为 挖坑填数+分治法下面举例来进行说明，主要有三个参数，i为区间的开始地址，j为区间
多种基础排序方法
小兔的萝卜的博客
03-19 913
一、插入排序   1.直接插入排序 依次将待排序序列中每一个记录插入到有序序列中，直到全部记录都排好序。 #include <bits/stdc++.h> using namespace std; void insertsort(int r[], int n) { for(int i = 2; i <= n; i++) { int j...
Java实现几种常见排序方法
03-06
### Java 实现几种常见排序方法 #### 泡泡排序（Bubble Sort） 泡泡排序是一种简单的排序算法，它重复地遍历待排序的数列，依次比较相邻的两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复...
数组的几种排序方法
03-24
本篇文章将深入探讨数组的几种常见排序方法，包括冒泡排序、选择排序和插入排序，这些都是基础且实用的排序算法，对于理解更复杂的排序算法有着重要的铺垫作用。 ### 冒泡排序 冒泡排序是一种简单直观的排序算法。...
Shell中字符串排序的几种方法
09-15
本文将详细介绍三种在Shell中对字符串进行排序的方法。 **方法一：按ASCII正向排序** 在Shell中，可以使用内置的`sort`命令对字符串进行ASCII值的正向排序。ASCII值是字符的一种编码方式，每个字符都有一个对应的...
几种常见排序算法的实现
07-29
本文将深入探讨六种常见的排序算法：选择排序、插入排序、冒泡排序、希尔排序、快速排序以及归并排序，它们都是编程实践中不可或缺的基础知识。 1. **选择排序（Selection Sort）**： 选择排序的工作原理是每一次...
开题报告达达宠物认领信息网站的设计与实现 已通过开题答辩的.docx
07-25
宠物认领信息网站的主要目的是为寻找宠物的失主和寻找新家的宠物提供一个在线的信息交流平台。通过这个平台，失主可以发布失宠信息，寻找走失或遗弃的宠物；而救助人或组织则可以发布待领养的宠物信息，为那些无家可归的宠物寻找一个永久的归宿。 这样的网站通常会提供一个详细的宠物数据库，包括照片、品种、年龄、健康状况等信息，以便让失主能够方便地找到自己的宠物。同时，网站还会提供一些相关的服务，如失主与救助人之间的在线交流、宠物匹配推荐、领养手续办理等，以帮助双方顺利完成宠物的认领和领养过程。 宠物认领信息网站的目的在于提高失宠找到宠物的几率，减少流浪宠物的数量，并为那些无家可归的宠物提供一个温馨的新家。同时，网站还能促进社会对流浪宠物的关注和保护，提高人们的动物保护意识。
开题报告创权法律服务系统 已通过开题答辩的.doc
07-25
进入20世纪80年代，我国加快了改革开放的步伐，市场经济体制已逐步形成，我国的经济发展受世人所瞩目，但法律法规的置后，使经济发展不规范问题暴露的相当严重，特别是社会整体信用的缺失，使消费环境不断恶化。而如今随着城镇化的高速推进，精神追求远不及物质发展迅速，维权问题也越来越成为人们十分关注的社会话题。 维权是指维护个人或群体的合法权益，范围包括人身损害、土地纠纷、 医疗事故、婚姻、家庭、继承等民事纠纷所进行的行政及司法诉讼。维护消费者合法权益关系着全社会每个人的利益，群众利益无小事。维护消费者合法权益正体现着“权为民所用，利为民所谋”。而现如今由于法律规则的不完善加上自身对法律知识的不了解，导致很多公民的权益问题在复杂的社会情况下无法得到妥善的解决，使得公民的财产和心理受到难以弥补的损失，严重威胁到社会的安全与稳定，公民之间的诚信与统一。因此更便捷、迅速地维护公民的合法权益，已经成为了一个刻不容缓去解决的社会问题。
Matlab实现豪猪优化算法CPO-TCN-Multihead-Attention多输入单输出回归预测算法研究.rar
07-25
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
人力资源-6 团结一致共创未来新员工座谈会.pptx
07-25
人力资源-6 团结一致共创未来新员工座谈会.pptx
《AI大模型应用》--基于PepperBot，可以保留上下文的LLM群聊机器人实现.zip
07-25
上接OpenAI、文心一言，下接QQ、微信、Telegram 个人深耕AI大模型应用领域积累的成果，希望对您有所帮助。有大模型账号、环境问题、AI大模型技术应用落地方案等相关问题，欢迎详聊，能为您解决问题是我的荣幸！ 个人深耕AI大模型应用领域积累的成果，希望对您有所帮助。有大模型账号、环境问题、AI大模型技术应用落地方案等相关问题，欢迎详聊，能为您解决问题是我的荣幸！ 个人深耕AI大模型应用领域积累的成果，希望对您有所帮助。有大模型账号、环境问题、AI大模型技术应用落地方案等相关问题，欢迎详聊，能为您解决问题是我的荣幸！ 个人深耕AI大模型应用领域积累的成果，希望对您有所帮助。有大模型账号、环境问题、AI大模型技术应用落地方案等相关问题，欢迎详聊，能为您解决问题是我的荣幸！ 个人深耕AI大模型应用领域积累的成果，希望对您有所帮助。有大模型账号、环境问题、AI大模型技术应用落地方案等相关问题，欢迎详聊，能为您解决问题是我的荣幸！ 个人深耕AI大模型应用领域积累的成果，希望对您有所帮助。有大模型账号、环境问题、AI大模型技术应用落地方案等相关问题，欢迎详聊，能为您解决问题是我的荣幸！
开题报告传统糕点 已通过开题答辩的.docx
07-25
理论意义： 1、网页设计是信息传播的重要手段，通过合理的布局、图文搭配等设计元素，可以更好地传递传统糕点的信息。理论上，这涉及到传播学、信息传递模型等方面的理论研究，确保信息能够被受众准确、清晰地接收。 2、用户体验理论强调用户与网页之间的交互和感知。在传统糕点推广网页设计中，理论上的考虑应该包括用户友好的界面、易于导航的网站结构，以及引导用户深入了解传统糕点的设计元素。
GBT 2423.1-2008-试验A-低温
最新发布
07-25
GBT 2423.1-2008-试验A-低温
unity排序方法有几种
03-28
在Unity中，常用的排序方法有以下几种： 1. 冒泡排序（Bubble Sort）：比较相邻的元素，如果前一个比后一个大，则交换它们的位置，一直重复，直到没有任何一对数字需要交换为止。 2. 快速排序（Quick Sort）：选取...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值