数据结构之排序算法

最新推荐文章于 2023-03-27 09:00:00 发布
最新推荐文章于 2023-03-27 09:00:00 发布
阅读量3.1k 收藏 18
点赞数 1
分类专栏： 数据结构&算法
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/fantasy_wxe/article/details/8712955
版权

排序算法

1.冒泡排序（Bubble Sort）

1)算法伪代码

for i = 1 : n
	swapped = false
	for j = n : i + 1
		if a[j] < a[j - 1]
			交换a[j]和a[j - 1]
			swapped = true
	排好序的数列：a[1...i]
	break if not swapped
end


2)算法原理过程

初始数列：5, 3, 2, 4, 1
i = 1
[
	5, 3, 2, 1, 4
	5, 3, 1, 2, 4
	5, 1, 3, 2, 4
	1, 5, 3, 2, 4
]

i = 2
[
	1, 5, 3, 2, 4
	1, 5, 2, 3, 4
	1, 2, 5, 3, 4
]

i = 3
[
	1, 2, 5, 3, 4
	1, 2, 3, 5, 4
]

i = 4
[
	1, 2, 3, 4, 5
]

3)代码实现

代码实现一：

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

void bubble_sort(int arr[], int length)
{
	int i, j;
	int temp;

	for(i = 0; i < length - 1; ++i)
	{
		for(j = length - 1; j > i; --j)
		{
			if(arr[j] < arr[j - 1])
			{
				temp = arr[j - 1];
				arr[j - 1] = arr[j];
				arr[j] = temp;
			}
		}
	}
}

void print_array(int arr[], int length)
{
	int i = 0;

	for(i = 0; i < length; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n\n");
}

int main(void)
{
	int arr[] = {4, 3, 6, 1, 7, 2, 10, 5, 8, 9};
	int length = 10;

	printf("Before sorting, the array is:");
	print_array(arr, length);

	printf("After Bubble Sorting, the ordered array is:");
	bubble_sort(arr, length);
	print_array(arr, length);

	return 0;
}


对于上述代码可以进行如下优化（swapped变量的作用是：当初始要排序的数列已经是有序的时候，只遍历一遍数列，就退出遍历循环）

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

void bubble_sort(int arr[], int length)
{
	int i, j;
	int temp;

	int swapped = 1;

	for(i = 0; swapped && i < length - 1; ++i)
	{
		swapped = 0;
		for(j = length - 1; j > i; --j)
		{
			if(arr[j] < arr[j - 1])
			{
				temp = arr[j - 1];
				arr[j - 1] = arr[j];
				arr[j] = temp;
				swapped = 1;
			}
		}
	}
}

void print_array(int arr[], int length)
{
	int i = 0;

	for(i = 0; i < length; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n\n");
}

int main(void)
{
	int arr[] = {4, 3, 6, 1, 7, 2, 10, 5, 8, 9};
	int length = 10;

	printf("Before sorting, the array is:");
	print_array(arr, length);

	printf("After Bubble Sorting, the ordered array is:");
	bubble_sort(arr, length);
	print_array(arr, length);

	return 0;
}

4)复杂度分析

稳定的
空间复杂度O(1)
时间复杂度:比较和交换的操作次数，O(n^2)

冒泡排序和插入排序有很多相似的地方。但是比插入排序有稍多的开销。

2.插入排序（Insert Sort）

 1)伪代码实现

for i = 2 : n
    for(k = i; k > 1 and a[k] < a[k - 1]; k--)
        swap a[k, k-1]
    ->排好序的前i个元素：a[1...i]
end

2)算法原理过程

初始无序元素：5, 3, 4, 9, 7, 2, 1, 6, 8

k = 2
   3, 5, 4, 9, 7, 2, 1, 6, 8

k = 3
   3, 4, 5, 9, 7, 2, 1, 6, 8

k = 4
   3, 4, 5, 9, 7, 2, 1, 6, 8

k = 5
   3, 4, 5, 7, 9, 2, 1, 6, 8

k = 6
   3, 4, 5, 7, 2, 9, 1, 6, 8
   3, 4, 5, 2, 7, 9, 1, 6, 8
   3, 4, 2, 5, 7, 9, 1, 6, 8
   3, 2, 4, 5, 7, 9, 1, 6, 8
   2, 3, 4, 5, 7, 9, 1, 6, 8

k = 7
   2, 3, 4, 5, 7, 1, 9, 6, 8
   2, 3, 4, 5, 1, 7, 9, 6, 8
   2, 3, 4, 1, 5, 7, 9, 6, 8
   2, 3, 1, 4, 5, 7, 9, 6, 8
   2, 1, 3, 4, 5, 7, 9, 6, 8
   1, 2, 3, 4, 5, 7, 9, 6, 8

k = 8
   1, 2, 3, 4, 5, 7, 6, 9, 8
   1, 2, 3, 4, 5, 6, 7, 9, 8

k = 9
   1, 2, 3, 4, 5, 6, 7, 8, 9

 

 

3)代码实现

#include <stdio.h>

void insert_sort(int arr[], int length)
{
	int i, j;
	int temp;

	for(i = 1; i < length; ++i)
		for(j = i; j > 0 && arr[j] < arr[j - 1]; --j)
		{
			temp = arr[j - 1];
			arr[j - 1] = arr[j];
			arr[j] = temp;
		}
}

void print_array(int arr[], int length)
{
	int i;
	for(i = 0;  i < length; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n\n");
}

int main(void)
{
	int arr[] = {4, 3, 6, 1, 7, 2, 10, 5, 8, 9};
	int length = 10;

	printf("Before sorting, the array is:");
	print_array(arr, length);

	printf("After Insert Sorting, the ordered array is:");
	insert_sort(arr, length);
	print_array(arr, length);

	return 0;
}

4)算法复杂度分析

时间复杂度：
最好情况为O(n)：即序列已经是升序排列，只需要进行比较操作n-1即可
最坏情况为O(n^2):即序列原来是降序排列，在进行升序排序时，需要n(n-1)/2次的比较，赋值操作是比较操作的次数加上(n-1)次，平均来说插入排序算法的时间复杂度为O(n^2)

空间复杂度：
额外空间O(1）

 

 该算法是排序算法中非常基础的算法，在最坏情况下，算法复杂度为O(n^2),
当数据量比较小，或已接近排好序的情况，该算法是个比较好的选择

3 选择排序（Select Sort）

1)伪代码

for i = 1 : n
      k = i
      for  j = i + 1 : n, 
             if a[j] < a[k]
                  k = j
       ->a[k]是a[i...n]中最小的元素
       交换a[i], a[k]
      -> 排好序的元素：a[1...i]
end

2）算法原理过程

初始无序数列：5, 2, 3, 1, 4
i = 1
[
    k = 1
    j = 2
   因为 a[j] < a[k]
   所以 k = j

 

   k = 2
   j = 3
   因为 a[j] > a[k]
   所以 k不变

 

   k = 2
   j = 4
   因为 a[j] < a[k]
   所以 k = j

 

   k = 4
   j = 5
   因为 a[j] > a[k]
   所以k不变
]
a[i]与 a[k]交换
最后结果为：1, 2, 3, 5, 4

i =  2
[
   过程和上面类似
]

3)代码实现 

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

void select_sort(int arr[], int length)
{
	int i, j, k;
	int temp;

	for(i = 0; i < length - 1; ++i)
	{
		k = i;
		for(j = i + 1; j < length; ++j)
		{
			if(arr[j] < arr[k])
				k = j;
		}
		temp = arr[i];
		arr[i] = arr[k];
		arr[k] = temp;
	}
}

void print_array(int arr[], int length)
{
	int i;
	for(i = 0;  i < length; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n\n");
}

int main(void)
{
	int arr[] = {4, 3, 6, 1, 7, 2, 10, 5, 8, 9};
	int length = 10;

	printf("Before sorting, the array is:");
	print_array(arr, length);

	printf("After Insert Sorting, the ordered array is:");
	select_sort(arr, length);
	print_array(arr, length);

	return 0;
}

4)算法复杂度分析

非稳定的，
空间复杂度：O(1)
时间复杂度：比较的次数,O(n^2)；交换的次数O(n)


选择排序算法的优点是交换的次数是最小的，因此对于交换的操作复杂度非常高的情况下，可以选择使用选择排序算法。

 4 快速排序（Quick Sort）

1)算法原理

初始数列：A[0],A[1],......,A[N-1]

首先任意选取一个数据（通常选用第一个数据）作为关键数据(key)，
然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。


值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。 　　
1）设置两个变量I、J，排序开始的时候：I=0，J=N-1； 　　
2）以第一个数组元素作为关键数据，赋值给key，即 key=A[0]； 　　
3）从J开始向前搜索，即由后开始向前搜索（J=J-1即J--），找到第一个小于key的值A[j]，A[j]与A[i]交换； 　　
4）从I开始向后搜索，即由前开始向后搜索（I=I+1即I++），找到第一个大于key的A[i]，A[i]与A[j]交换； 　　
5）重复第3、4、5步，直到 I=J； (3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。找到并交换的时候i， j指针位置不变。
另外当i=j这过程一定正好是i+或j-完成的最后令循环结束。

一趟快速排序的算法是： 　　

2)算法实现过程

待排序的数组A的值分别是：49 38 65 97 76 13 27 


（初始关键数据：key=49） 注意关键key永远不变，永远是和key进行比较，无论在什么位置，最后的目的就是把key放在中间，小的放前面大的放后面。 　
　A[0] A[1] A[2] A[3] A[4] A[5] A[6] 
  49   38   65    97   76   13   27 
　进行第一次交换后：27 38 65 97 76 13 27 　　( 按照算法的第三步从后面开始找，此时：J=6，A[i] = A[j]) 　　

  进行第二次交换后：27 38 65 97 76 13 65 　　( 按照算法的第四步从前面开始找>key的值，65>49,两者交换，此时：I=2 ,A[j] = A[i]) 　　

  进行第三次交换后：27 38 13 97 76 13 65 　　( 按照算法的第五步将又一次执行算法的第三步从后开始找,此时:J=5,A[i] = A[j]) 　　

  进行第四次交换后：27 38 13 97 76 97 65 　　( 按照算法的第四步从前面开始找大于key的值，97>49，两者交换，此时：I=3,J=5, A[j] = A[i] ) 　　
  此时再执行第三步的时候就发现I=J=4，从而结束一趟快速排序，然后把A[i] = key后:27 38 13 49 76 97 65
  那么经过一趟快速排序之后的结果是：27 38 13 49 76 97 65，即所有大于key=49的数全部在49的后面，所有小于key=49的数全部在49的前面。

3)代码实现

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

int partition(int arr[], int low, int high)
{
    int key = arr[low];

    while(low < high)
    {
        while(low < high && arr[high] >= key)
        {
            high--;
        }
        arr[low] = arr[high];

        while(low < high && arr[low] <= key)
        {
            low++;
        }
        arr[high] = arr[low];
    }

    arr[low] = key;
    return low;
}

void __quick_sort(int arr[], int low, int high)
{
    int mid = partition(arr, low, high);

    if(mid - 1 > low)
    {
        __quick_sort(arr, low, mid - 1);
    }
    if(mid + 1 < high)
    {
        __quick_sort(arr, mid + 1, high);
    }
}

void quick_sort(int arr[], int length)
{
    __quick_sort(arr, 0, length - 1);
}

void print_array(int arr[], int length)
{
	int i;

	for(i = 0; i < length; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n\n");
}

int main()
{
	int arr[] = {49 ,38, 65, 97, 76, 13, 27};
	int length = 7;

	printf("Before sorting, the array is:");
	print_array(arr, length);

	printf("After Quick Sorting, the ordered array is:");
	quick_sort(arr, length);
	print_array(arr, length);

	return 0;
}

4)算法复杂度分析

非稳定的算法

空间复杂度：O(lg(n))

时间复杂度：O(n.lg(n))


归并排序（Merge Sort）

1)算法原理

归并排序就是将两个（或者两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的，

然后再把有序的子序列合并为整体有序序列。

初始数列为：A[0],A[1],...,A[n-1]
算法实现的步骤如下：
1) 把0~n-1的数组分为左数组A[0,...,n/2]和右数组A[n/2 + 1,..., n-1];
2) 对左数组和右数组进行迭代排序
3) 将排好序的左数组和右数组进行合并，那么最后的整个数组就是有序的数组序列。

2)算法实现过程

算法实现过程示意图如下：


3)代码实现

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

void merge(int arr[], int low, int mid, int high)
{
	int length = high - low + 1;

	int *pData = NULL;
	int left = low;
	int right = mid + 1;

	int all = 0;

	//分配空间给pData；
	pData = (int*)malloc(sizeof(int) * length);
//	assert(NULL != pData);
	memset(pData, 0, length);

	//把排好序的左数组和右数组合并后放入pData中；
	while(left <= mid && right <= high)
	{
		if(arr[left] <= arr[right])
		{
			pData[all] = arr[left];
			left++;
			all++;
		}
		else
		{
			pData[all] = arr[right];
			right++;
			all++;
		}
	}

	//移动剩下的数据
	if(left <= mid)
	{
		memmove(&pData[all], &arr[left], sizeof(int) * (mid - left + 1));
	}

	if(right <= high)
	{
		memmove(&pData[all], &arr[right], sizeof(int) * (high - right + 1));
	}

	//把排好序的数列移动到原始数组中
	memmove(&arr[low], pData, sizeof(int) * (high - low + 1));

	free(pData);
}


void __merge_sort(int arr[], int low, int high)
{
	int mid = 0;

	if(low < high)
	{
		mid = low + (high -low) / 2;
		__merge_sort(arr, low, mid);
		__merge_sort(arr, mid + 1, high);
		merge(arr, low, mid, high);
	}
}

void merge_sort(int arr[], int length)
{
	__merge_sort(arr, 0, length - 1);
}

void print_array(int arr[], int length)
{
    int i;

    for(i = 0; i < length; i++)
    {
        printf("%d ", arr[i]);
    }
	printf("\n\n");
}

int main(void)
{
	int arr[] = {49 ,38, 65, 97, 76, 13, 27};
	int length = 7;

	printf("Before sorting, the array is:");
	print_array(arr, length);

	printf("After Merge Sorting, the ordered array is:");
	merge_sort(arr, length);
	print_array(arr, length);

	return 0;
}

4)算法复杂度分析

归并排序算法可选择用于各种场合，

稳定的排序。即相等的元素的顺序不会改变


时间复杂度为O(nlogn) 这是该算法中最好、最坏和平均的时间性能。 　　

空间复杂度为 O(n) 。
比较操作的次数介于(nlogn) / 2和nlogn - n + 1。 　
赋值操作的次数是(2nlogn)

归并排序比较占用内存，但却效率高且稳定的算法。

引自http://baike.baidu.com/view/19000.htm


2022-07-17
关注
  • 1
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言 数据结构 快速排序算法
04-28
c语言版本的数据结构的快速排序算法，适用于新手学习
php伪代码排序,PHP实现排序算法
weixin_30324103的博客
03-27 215
一、冒泡排序大O符号：order，译为阶，也可以理解为数量级。冒泡排序原理步骤每一轮排序找到最大的值，放在数组的最后，并且，排好序的数不再参与下一轮的排序；每一轮的排序规则是：每次从第一个数开始，与其右边的数进行比较，大的值放到右边，右边的值再依次往下进行比较，直到进行到未排序数的最后一个数为止；排序的结束：当未排序的数只有一个时，就完成了排序。冒泡排序伪代码数组长度：lengthfunction...
冒泡排序(Bubble Sort)
云原生Java Web领域技术博客
11-26 5033
冒泡排序是一种基础的交换排序。之所以叫做冒泡排序，因为每一个元素都可以像小气泡一样，向数组的一侧移动。
冒泡排序算法
ccc369639963的博客
01-20 3163
冒泡排序算法 冒泡排序是所有排序算法中最简单、最易实现的算法，有时也称为起泡排序算法。 使用冒泡排序算法对 n 个数据进行排序，实现思路是：从待排序序列中找出一个最大值或最小值，这样的操作执行 n-1 次，最终就可以得到一个有序序列。 举个例子，对 {14, 33, 27, 35, 10} 序列进行升序排序（由小到大排序），冒泡排序算法的实现过程是： 从 {14, 33, 27, 35, 10} 中找到最大值 35； 从 {14,33,27,10} 中找到最大值 33； 从 {14, 27, 10} 中找到
C语言数据结构+冒泡排序的实现
qq_63713328的博客
03-27 1375
冒泡排序是一种简单的排序算法，它重复地遍历要排序的数组，比较每对相邻的元素，并按照顺序交换它们的位置，直到没有任何一对元素需要交换为止。冒泡排序的时间复杂度为O(n^2)，其中n为要排序的元素个数。虽然冒泡排序的效率不是很高，但是它的实现简单易懂，适合排序元素个数较少的数组,适用场景与我上期的希尔排序恰恰相反,如果对希尔排序有疑问,请看我上期希尔排序.
算法1.2.冒泡排序
a1191651771的博客
10-22 493
一、什么是冒泡排序 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单且最基础的排序算法，是新手入门学习排序算法的必经之路。 冒泡排序的思路非常简单，就是不断选出数组中的最大值或最小值，每选出一个数，参与选举数组长度减一。 从下图中可以形象的看到，越大的数字代表越大的泡泡，从而最先往上浮，泡泡最终根据大小先后浮出水面。 二、冒泡排序的实现 1 基本实现思路 冒泡排序有几种简单的实现方式，我在这里将以从小到大排列数组为例展示冒泡算法。 假定有一数组 5,2,4,6,1,3{5,2,4,6,1,
数据结构与算法（一）冒泡排序
qq_36451065的博客
01-17 1045
介绍一下冒泡排序，思想挺简单，跟个熊孩子一样的算法，顾名思义，冒泡排序就是让数组元素像水中的气泡一样逐渐上浮，进而达到排序的目的。下面就是冒泡排序的伪代码： bubbleSort(A,n)//包含N个元素的0起点数组A  flag=1; while(flag){ flag=0; for(int j=0;j&lt;n-1;j++){ if(A[j]&lt;A[j-1]) swap(A[j]...
数据结构快速排序算法的实现
12-21
快速排序算法c语言
合并排序 数据结构 排序算法
最新发布
12-22
合并排序 数据结构 排序算法
冒泡排序法
专注游戏研发
12-23 583
冒泡排序法一 冒泡排序了解二 冒泡排序伪代码实现三 冒泡排序 c++ 代码实现四 插入排序时间复杂度与稳定性分析。 一 冒泡排序了解 冒泡排序法就是让数组元素像水中的气泡一样逐渐上浮，进而达到排序的目的。 流程图： 二 冒泡排序伪代码实现 bubbleSort(A,N) { flag=1 i=0; //未排序部分的起始下标，因为每次遍历排序都会增加一个元素到排序部分 wh...
排序算法总结(3)--冒泡排序
liqiutuoyuan的博客
05-18 845
冒泡排序的介绍和代码实现
C语言-冒泡排序算法
weixin_44749255的博客
03-11 332
什么是冒泡排序呢？冒泡排序的英语名是Bubble Sort，是一种最基础的交换排序。 大家一定都喝过汽水吧，汽水中常常有许多小小的气泡，往上飘，这是因为组成小气泡的二氧化碳比水要轻，所以小气泡才会一点一点的向上浮。而冒泡排序之所以叫冒泡排序，正是因为这种排序算法的每一个元素都可以向小气泡一样，根据自身大小，一点一点向着数组的一侧移动。具体如何移动呢？我们来看一下例子： 伪代码表示： BubbleSort(input ele[],input length) for i <- 1 to le
数据结构-排序(C语言与伪代码)
qhu1600417010的博客
05-02 5173
这里写目录标题1冒泡排序伪代码原理代码实现2插入排序伪代码原理代码实现3时间复杂度下届4希尔排序伪代码代码实现Hibbard序列5选择排序选择排序原理伪代码代码实现6堆排序堆排序算法1 1冒泡排序 1.待排序数据在数组和链表均可 2.当严格不等的时候，才交换，就是说当等于的时候，不交换这说明算法是稳定的 伪代码 void Bubble_Sort(ElementType A[], int N) { for (p = N - 1; p > 0; p--) { flag = 0; for (i
JAVA版本冒泡排序算法伪代码以及实现和复杂度分析
osjedufei的专栏
10-27 3508
冒泡排序 ：主要思路 主要有三个两个主要过程 （1）两两元素相比较 如果(升序)情况下大的往后排 、 (倒叙)情况下 小的往后排 （2） 排序在最右端的 代表 已经排好序的 将不在参与 大小比较 ...
算法-蛮力法-冒泡排序
m0_53017880的博客
11-19 996
c++实现蛮力排序中的起泡排序（未改进）
选择排序的理解
闻道有先后
05-07 217
思路： 重复（元素个数-1）次 把第一个没有排序过的元素设置为最小值 遍历每个没有排序过的元素 如果元素 < 现在的最小值 将此元素设置成为新的最小值 将最小值和第一个没有排序过的位置交换 package com.zzh; import edu.princeton.cs.algs4.StdIn; import edu.princeton.cs.algs4.StdOut; // pu...
汇编语言-MIPS-冒泡排序(含伪代码)
littlemou-解的博客
03-27 1972
汇编语言-MIPS-冒泡排序题目描述一、C++伪代码二、不多说了，直接上MIPS代码 题目描述 冒泡排序介绍 一、C++伪代码 # Pseudocode description of algorithm: # 函数sort: #冒泡排序函数 # t1=0 # t2=0 # a2=4*a1 #
冒泡排序伪代码_最容易明白系列--数据结构与算法详解--冒泡排序 bubble sort
weixin_39985472的博客
12-16 4403
冒泡排序：1、一组数据 n 个，需要把这组数据按照从小到大的顺序排序（可以想象成从左到右排放着，顺序乱序）。2、算法解析：从小到大排序的冒泡，就是每次都从第一个数据开始，不断往右搬移更大的数。（可以想象有n个气泡，每次把最大的搬到最右边，就是每次排好一个气泡）搬移的过程是：当前位置与下一个位置的值比较，左边比右边大，就交换左右的值，否则不交换。然后前进一步，然后继续当前位置与下一个位置值比较继续操...
冒泡排序c++代码_教你写一手漂亮的伪代码
weixin_39848347的博客
12-04 2766
前言最近在复盘《算法设计与分析》这门课程的时候，发现老师写得一手漂亮的伪代码，着实羡慕不已，看他写其实已经知道大致写伪代码的规则，但本着严谨的态度，还是系统的学习和整理出来。在学习过程中，我们不可能将每一个算法都完完整整敲一遍，那么伪代码就可以很快捷和清晰的写出对一个算法的解决思路。我在网上查到的博客中要么写的过于繁琐，要么就是没有实例，这也激起了我想要整理这篇文章的动力，若文章中有错误或者不足，...
数据结构与排序算法详解
"该资源是一份关于数据结构中排序算法的课件，主要涵盖了内部排序的各种方法，包括插入排序、快速排序、堆排序、归并排序、基数排序，并对各种排序方法进行了综合比较。此外，还讲解了排序的定义、内部排序与外部...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值