数据结构之排序

内排序探索：冒泡、选择、插入与高效算法详解
原创 已于 2023-03-13 15:14:17 修改 · 2.7k 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #c语言

于 2022-04-02 18:46:21 首次发布

数据结构之排序

数据结构相关文章

数据结构之线性表

数据结构之栈和队列

数据结构之二叉树

文章目录

前言

排序就是按照非递增或者非递减的方式使其成为一个有序的序列。另外需要注意的是，如果排序前两相等的元素之间的相对位置与排序后相比没有发生改变，那就称这个排序是稳定的，反之，其就是不稳定的排序。

根据在排序过程中待排序记录是否被全部放置于内存中分为：内排序和外排序。

内排序是在排序整个过程中，待排序的所有记录全部被放置在内存中。外排序是由于排序的记录个数太多，不能同时放置在内存，整个排序过程需要在内外存之间多次交换数据才能进行。本文讲解的都是内排序。

一、冒泡排序（Bubble Sort）

冒泡排序算法思想：

冒泡排序是一种交换排序，它的基本思想就是：两两比较相邻元素的大小，如果反序则交换，直到没有反序为止。

代码如下：

void Swap(int* a, int* b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}
void BubbleSort(int* arr, int size)
{
    //要比较的趟数
    for (int i = 1; i < size; i++)
    {
        int sign = 1;
        //每一趟冒泡排序的比较
        for (int j = i; j < size; j++)
        {
            if (arr[j] < arr[j - 1])
            {
                Swap(&arr[j], &arr[j - 1]);
                sign = 0;
            }
        }
        //若此趟排序没有移动元素，说明是有序的，不需要再进行之后每一趟的比较了
        if (sign == 1)
        {
            break;
        }
    }
}

冒泡排序的时间复杂度为O(n²)。。

二、简单选择排序（Simple Select Sort）

简单选择排序算法思想：

简单选择排序就是通过比较当前位置及之后的序列中元素的大小，选出相应元素放在当前位置。

代码如下：

void Swap(int* a, int* b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

void SelectSort(int* arr, int size)
{
    //排序趟数
    for (int i = 0; i < size - 1; i++)
    {
        //每趟排序选择一个对应元素放入当前位置
        int min = i;
        for (int j = i + 1; j < size; j++)
        {  
            if (arr[min] > arr[j])
            {
                min = j;
            }
        }
        if (i != min)
        {
            Swap(&arr[min], arr[i]);
        }
    }
}

简单选择排序的时间复杂度为O(n²)。。

三、直接插入排序(Straight Insertion Sort)

直接插入排序算法思想：

直接插入排序的基本操作是将一个记录插入到已经排好序的有序表中，从而得到一个新的有序序列。

代码如下：

void Swap(int* a, int* b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

void InertSort(int* arr, int size)
{
    for (int i = 1; i < size; i++)
    {
        int end = i;
        while (end > 0)
        {
            if (arr[end] < arr[end - 1])
            {
                Swap(&arr[end], &arr[end - 1]);
                --end;
            }
            else
            {
                break;
            }
        }
    }
}

直接插入排序的时间复杂度是O(n²)。

以上三种排序算法属于简单排序算法，接下来的四种排序算法为改进算法。将为大家重点分析及讲解。

四、希尔排序（Shell Sort）

希尔排序是D.L.Shell于1959年提出来的一种排序算法，在这之前排序算法的时间复杂度基本都是O(n²)，希尔排序算法突破这个时间复杂度的第一批算法之一。

我们上面讲到过，直接插入排序，应该说，它的效率在某些时候是很高的，比如在序列本身就是基本就有序的时候，我们只需要少量的插入操作，就可以完成整个序列的排序工作，此时直接插入非常有效。另外，在数据较少时，直接插入排序的优势也比较明显。

可是，这两种条件有些苛刻，不能总指望要排序的序列都是这样的吧！虽然条件有时可能不满足，但是我们要学会去创造条件。于是，大神希尔研究出了一种排序算法，对直接插入排序更改后可以增加效率。

希尔排序算法思想：

我们可以将整个待排序序列分为若干待排序的子序列，对子序列进行直接插入排序，当整个序列基本有序时，在对全体记录进行一次直接插入排序。

但是应当注意，子序列不是直接连续的子序列，而应当是跳跃连续的子序列：将相距某个“间隔量”的元素组成一个子序列，这样才能保证在子序列内分别进行直接插入排序后得到的结果是基本有序而不是局部有序。

排序过程如下图所示：
相同颜色的为同一子序列的元素。
在这里插入图片描述
之后我们缩小间隔，再次排序
在这里插入图片描述
最后，对这个基本有序的序列进行直接插入排序。
在这里插入图片描述

代码如下：

void Swap(int* a, int* b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

void ShellSort(int* arr, int size)
{
    int gap = size;
    while (gap >= 1)
    {
        int gap = gap / 3 + 1;
        //要排序子序列个数
        for (int i = 0; i < gap; i += 1)
        {
            //子序列的直接插入排序
            for (j = i + gap; j < size; j += gap)
            {
                int end = j;
                while (end >= gap)
                {
                    if (arr[end] < arr[end - gap])
                    {
                        Swap(&arr[end], &arr[end - gap]);
                    }
                    else
                    {
                        break;
                    }
                }
            }
        } 
    }
}

应当注意，间隔量的最后一次的值必须是一，另外，由于希尔排序是跳跃式移动的，其并不是一种稳定的排序算法。希尔排序的时间复杂度近似为O(n1.5)。

五、堆排序（Heap Sort）

前文说到过简单选择排序，它在待排序的n个元素中选择一个最小或最大的元素需要比较n - 1次，可惜的是，它并由有把每一趟的结果保存下来，因而之后的排序又重复的执行了这些操作。如果可以做到，在每次选择最小元素的同时，并根据比较结果对其他元素进行调整，那么排序的效率就会非常高了。而堆排序就是对简单选择排序的一种改进。

堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大根堆。反之称为小根堆。

堆排序算法思想：

堆排序就是利用堆（这里我们选择大根堆）进行排序的算法。基本思想是：

  1. 将待排序序列构造成一个大根堆。此时，整个序列的最大值就是堆顶的根结点。
  2. 将它于堆数组的末尾元素交换，此时末尾元素就是整个数组元素的最大值。然后将剩余的n - 1个元素重复第一步和第二步。

堆的向下调整算法：
图示如下：
首先从最后一个非叶子节点开始向下调整，在依此遍历之前的叶子节点，进行相应操作。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

代码如下：

void AdjustDown(int* arr, int size, int parent)
{
    int child = parent * 2 + 1;
    while (child < size)
    {
        //选择左右孩子中较大者
        if (child + 1 < size && arr[child + 1] > arr[child])
        {
            ++child;
        }
        //再将较大者于双亲结点比较
        if (arr[child] > arr[parent])
        {   
            Swap(&arr[child], &arr[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            break;
        }
    }
}

利用向下调整算法实现堆排序
图示如下：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

代码如下：

void HeapSort(int* arr, int size)
{
    for (int i = (size - 1 - 1) / 2; i >= 0; --i)
    {
        AdjustDown(arr, size, i);
    }
    int end = size - 1;
    while (end > 0)
    {
        Swap(arr, &arr[end]);
        AdjustDown(arr, end, 0);
        --end;
    }
}

若对双亲结点和子结点的位置关系有疑问，请见数据结构之二叉树

堆排序的时间复杂度是O(nlog2n)。

六、归并排序（Merging Sort）

前面我们讲到了堆排序，因为其利用了完全二叉树的深度是log2n + 1(向下取整)的特性。而归并排序就是一种更加简单且直接利用完全二叉树来排序的。

归并排序算法思想：

假设我们有n个元素，可以将这n个元素看成n个有序的子序列，每个子序列的长度为一，然后两两归并，如此重复直到得到一个长度为n的有序序列为止，这种排序方法称为2路归并排序。

如下图所示：
在这里插入图片描述

非递归代码如下：

#include<string.h>
#include<errno.h>

void _MergeSortN(int* arr, int* temp, int start1, int end1, int start2, int end2)
{
	int i = start1;
	int start = start1;
	while (start1 <= end1 && start2 <= end2)
	{
		if (arr[start1] > arr[start2])
		{
			temp[i] = arr[start2++];
		}
		else
		{
			temp[i] = arr[start1++];
		}
		++i;
	}

	while (start1 <= end1)
	{
		temp[i++] = arr[start1++];
	}
	while (start2 <= end2)
	{
		temp[i++] = arr[start2++];
	}

	for (i = start; i <= end2; i++)
	{
		arr[i] = temp[i];
	}
}
void MergeSortN(int* arr, int size)
{
	int* temp = (int*)malloc(sizeof(int) * size);
	if (temp == NULL)
	{
		printf("%s\n", strerror(errno));
		exit(-1);
	}
	int gap = 1;
	while (gap < size)
	{
		for (int i = 0; i < size; i += gap * 2)
		{
			if (i + gap >= size)
			{
				break;
			}
			if (i + gap * 2 - 1 >= size)
			{
				_MergeSortN(arr, temp, i, i + gap - 1, i + gap, size - 1);
			}
			else
			{
				_MergeSortN(arr, temp, i, i + gap - 1, i + gap, i + 2 * gap - 1);
			}
		}

		gap *= 2;
	}

	free(temp);
	temp = NULL;
}

在这里插入图片描述

递归代码如下：

#include<string.h>
#include<errno.h>

void _MergeSort(int* arr, int* temp, int start, int end)
{
    if (start >= end)
    {
        return;
    }
    int mid = (start + end) >> 1;
    _MergeSort(arr, temp, start, mid);
    _MergeSort(arr, temp, mid + 1, end);
    int i = start;
    int start1 = start;
    int start2 = mid +  1;
    while (start1 <= mid && start2 <= end)
    {
        if (arr[start1] > arr[start2])
        {
            temp[i++] = arr[start2++];
        }
        else
        {
            temp[i++] = arr[start1++];
        }
    }

    while (start1 <= mid)
    {
        temp[i++] = arr[start1++];
    }
    while (start2 <= end)
    {
        temp[i++] = arr[start2++];
    }

    for (i = start; i <= end; i++)
    {
        arr[i] = temp[i];
    }

}

void MergeSort(int* arr, int size)
{
    int* temp = (int*)malloc(sizeof(int) * size);
    if (temp == NULL)
    {
        printf("%s\n", strerror(errno));
        exit(-1);
    }
    _MergeSort(arr, temp, 0, size - 1);

    free(temp);
    temp = NULL;
    
}

归并排序时间复杂度为O(nlog2n)。

七、快速排序（Quick Sort）

希尔排序相当于直接插入排序的升级，它们同属于插入排序类，堆排序相当于简单选择排序的升级，它们同属于选择排序类。而快速排序其实就是我们前面认为最慢的冒泡排序的升级，它们都属于交换类排序。即它也是通过不断地比较和移动交换来实现排序的，只不过它的实现增大了序列的比较和移动的距离，将元素较大的从前直接移动到后面，将元素较小的直接从后移动到前面，从而减少了总的比较次数和移动交换次数。

快速排序算法思想

通过一趟排序将待排序序列分割成独立的两部分，其中一部分的元素均小于或大于另一部分元素，然后再分别对这两部分元素再进行分隔和排序，以达到整个序列有序的目的。

下面将介绍快排的三种方法：

  1. hoare

首先取序列最左侧元素为key，然后让两个指针一个先从序列右侧找小于key的元素，找到之后再让另一个指针从序列左侧找到大于key的元素，交换两元素位置，直到二者相遇。

如下图所示：

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

代码如下：

int GetMinIndex(int* arr, int start, int end)
{
    int mid = (start + end) / 2;
    if (arr[start] > arr[end])
    {
        if (arr[mid] > arr[start])
        {
            return start;
        }
        else
        {
            if (arr[mid] > arr[end])
            {
                return mid;
            }
            else
            {
                return end;
            }
        }
    }
    else
    {
        if (arr[mid] > arr[end])
        {
            return end;
        }
        else
        {
            if (arr[mid] > arr[start])
            {
                return mid;
            }
            else
            {
                return start;
            }
        }
    }
}

void Swap(int* a, int* b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

int PartSort(int* arr, int start, int end)
{
    int mid = GetMinIndex(arr, start, end);
    Swap(&arr[mid], &arr[start]);
    int key = arr[start];
    int left = start;
    int right = end;

    while (left< right)
    {
        while (left < right && arr[right] >= key)
        {
            ++right;
        }
        while (left < right && arr[left] <= key)
        {
            ++left;
        }
        Swap(&arr[left], &arr[right]);
    }
    Swap(&arr[start], &arr[left]);
    return left;
}
void QuickSort(int* arr, int start, int end)
{
    if (start >= end)
    {
        return;
    }

    int mid = PartSort(arr, start, end);
    QuickSort(arr, start, mid);
    QuickSort(arr, mid + 1, end);

}

为了防止出现快速排序的最差情况，加入了三数取中的优化。

  1. 挖坑法

代码如下：


int PartSort(int* arr, int start, int end)
{
    int mid = GetMinIndex(arr, start, end);
    Swap(&arr[start], &arr[mid]);
    int key = arr[start];
    int left = start;
    int right = end;

    while (left < right)
    {
        while (left < right && arr[right] >= key)
        {
            --right;
        }
        arr[left] = arr[right];
        while (left < right && arr[left] <= key)
        {
            ++left;
        }
        arr[right] = arr[left];
    }
    arr[left] = key;
    return left;
}

void QuickSort(int* arr, int start, int end)
{
    if (start >= end)
    {
        return;
    }

    int mid = PartSort(arr, start, end);
    QuickSort(arr, start, mid);
    QuickSort(arr, mid + 1, end);

}
  1. 前后指针法

代码如下：


int PartSort3(int* arr, int start, int end)
{
    int mid = GetMidIndex(arr, start, end);
    Swap(&arr[start], &arr[mid]);
    int key = arr[start];
    int prev = start;
    int cur = start + 1;

    while (cur <= end)
    {
        if (arr[cur] < key && (++prev) != cur)
        {
            Swap(&arr[prev], &arr[cur]);
        }
        ++cur;
    }

    Swap(&arr[start], &arr[prev]);
    return prev;
}

void QuickSort(int* arr, int start, int end)
{
    if (start >= end)
    {
        return;
    }

    int mid = PartSort(arr, start, end);
    QuickSort(arr, start, mid);
    QuickSort(arr, mid + 1, end);

}

快速排序时间复杂度为O(nlog2n)。

总结

根据排序过程中方借助的主要操作，我们将内排序分为：插入排序、交换排序、选择排序和归并排序四类。
在这里插入图片描述
下面是各种排序算法的各项指标：
在这里插入图片描述
应当注意简单选择排序根据算法情况的不同，也有可能是不稳定的一种算法。

C语言中排序方法汇总
Ohh_ckx的博客
11-10 869
C语言几种常见的排序方法 一，选择排序 步骤：1，在未排序的n个数（a[0]~a[n]）中找出最小的数，将其与a[0]交换； 2，在剩下的未排序的n-1个数（a[1]~a[n]）中找出最小的，将其与a[1]交换； … n-1步：在剩下的未排序的2个数（a[n-2]~a[n-1]）中找到最小的数，将其与a[n-2]交换。 代码样例如下： #include<stdio.h> int mai...
【数据结构之排序系列】直接插入排序，冒泡排序，直接选择排序，堆排序，希尔排序
胡坚涛的博客
01-30 1855
排序算法章节在校招方面考察是相对比较频繁的，所以本章中所学习的所有排序算法需要引起很大的重视。需要掌握各种排序算法的时间复杂度
冒泡排序算法的实现和优化~
m0_64365419的博客
01-16 3069
拿上面这种情况解释，也就是说，下一次，我们第一轮结束之际，需要记录元素3的索引，也就是4，第二轮比较的时候，只需要将前五个元素一一进行比较。
数据结构之冒泡排序
yeyueyouhun的博客
03-28 387
排序：假设含有n个记录的序列为{r1，r2，......，rn}，其相应的关键字为{k1，k2，......，kn}，需确定1,2，.......，n的一种排列p1,p2,.......,pn，使其相应的关键字满足kp1<=kp2<=,......,<=kpn(非递减或非递增）关系.即使得序列称为一个按关键字有序的序列{rp1,rp2,.....,rpn}，这样的操作称为排序。 ...
排序算法
BeidouInc的博客
08-02 496
排序的概念 概念 排序是计算机内经常进行的一种操作，其目的是将一组无序的数据元素调整为有序的数据元素的过程。 操作 比较：任意两个数据元素通过比较操作确定先后次序。 //比较数组中两个数据 if (arr[i] > arr[j]) //arr[i]大于arr[j] else //arr[i]小于arr[j] 交换：数据元素之间需要交换才能得到预期结果。 //数据交换函数 vo...
排序——排序的基本概念
05-25 2015
1，排序的一般定义： 1，排序是计算机内经常进行的一种操作，其目的是将一组“无序”的数据元素调整为“有序”的数据元素； 2，无序到有序就是排序； 2，排序的数学定义： 1，假设含 n 个数据元素序列为{R1, R2, ..., Rn}，其相应的关键字序列为{K1, K2, ..., Kn}，这些关键字相互之间可以进行比...
c语言 数据结构 快速排序算法
04-28
c语言版本的数据结构的快速排序算法，适用于新手学习
数据结构之排序（9种）
齐梦星空
03-01 3188
概览 插入排序 直接插入排序 将数组分为两部分，前半部分有序，后半部分无序，依次从后面取数据，插入到前面指定位置。 def insertSort(nums): size = len(nums) for i in range(1, size): temp = nums[i] # 待排序的数据 count = i-1 # 代表前面有count个数据...
数据结构8种排序算法动态演示
02-21
该程序使用VC6.0工具开发，使用MFC单文档实现数据结构8种排序算法的图形界面动态演示，更加形象的展示排序过程，八种排序算法包括插入排序（直接插入排序、折半插入排序、希尔排序）、选择排序（直接选择排序、堆...
数据结构学习笔记排序算法：基数排序
最新发布
09-17
数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数...
排序算法 - 堆排序详解
张大安的博客
05-17 3632
预备知识 堆是具有以下性质的完全二叉树： 每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆。 每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。 注意 : 没有要求结点的左孩子的值和右孩子的值的大小关系。 如图： 同时，我们对堆中的结点按层进行编号，将这种逻辑结构映射到数组中就是下面这个样子 特点 该数组从逻辑上讲就是一个堆结构，要查找数组中某个数的父结点和左右孩子结点，设数组索引为i，那么 父结点索引：(i-1)/2 左孩子索引：2*i+1 右孩子索引：2*i+2 可得 大顶堆特点
数据结构与算法（C语言） | 排序算法
Shannon
08-21 1127
　排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。 ——–假设含有n个记录的序列为{r1,r2,…,rn}，其相应的关键字分别为{k1,k2,…,kn}，需确定1,2,…,n的一种排列p1,p2,…pn,使其相应的关键字满足kp1&lt;=kp2&lt;=…&lt;=kpn非递减（或非递增）关系，即使得序列成为一个按关键字有序的序列{rp1,rp2,…...
堆排序的基本原理和实现方法（Java）
qq_41291067的博客
10-27 1478
堆排序的基本原理： 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。 堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆, 注意 : 没有要求结点的左孩子的值和右孩子的值的大小关系。 每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆 大顶堆举例说明： 我们对堆中的结...
【数据结构】各种排序讲解
m0_73222051的博客
03-16 709
上面的代码难免会有疏漏，如果各位大佬发现错误，请一定要指正🙏✏️ 评论，你的意见是我进步的财富！
排序 算法
AmazingP的博客
10-22 470
稳定排序与不稳定排序： 如果我们对一串数字排序，那么稳定与否并不是很重要，因为一串数字的属性是单一的，就是数值的大小。但是排序的元素的属性往往不是只有一个属性，例如我们对一群人进行年龄排序，但是人除了年龄属性还有身高体重属性，在年龄相同时如果不想破坏原先身高体重的次序，就必须用稳定排序算法。 判断某个排序算法是否稳定，可以简单的理解为：排序前后两个相等的数在其在序列的前后位置和排序后它们两个的前后位置顺序是否相同。 如果相同，则是稳定排序算法。 如果不同，则是不稳定排序算法。 冒泡排序算法实现 原理： 排序
数据结构（C语言实现）——常见排序算法的基本思想及实现（快速排序的三种方法和优化及非递归实现快速排序）
_Fiora的博客
04-22 1887
本文介绍了几种数据结构中常见的排序算法，着重讲解了快速排序的三种实现方法，并优化了快速排序，还通过非递归的方式实现了快速排序
《数据结构与算法》（二十一）- 简单排序算法详解：冒泡、简单选择、直接插入
程序园@大Null
11-17 1675
目录前言1. 排序的基本概念与分类1.1 排序的稳定性1.2 内排序与外排序1.3 排序用到的结构与函数2. 冒泡排序2.1 最简单排序的实现2.2 冒泡排序算法2.3 冒泡排序优化2.4 冒泡排序复杂度分析3. 简单选择排序3.1 简单选择排序算法3.2 简单选择排序复杂度分析4. 直接插入排序4.1 直接插入排序算法4.2 直接插入排序复杂度分析5. 总结 前言 部分内容摘自程杰的《大话数据结构》 1. 排序的基本概念与分类   排序是我们生活中经常会面对的问题。同学们做操时会按照从矮到高排列；老师查
排序算法篇 - 冒泡排序
郭龙飞的学习博客
07-27 785
基本介绍 冒泡排序（Bubble Sort）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素主键从前移向后部，就像水底下的气泡一样逐渐向上冒。因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换，从而减少不必要的比较。 推导过程 原始数组：3，9，-1，10，2 #第一趟排序 (1) 3，9，-1，10，2 #arr[0]和arr[1]比
数据结构（ 排序）
会思想的苇草i的博客
02-20 2385
排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。排序的目的是为了便于查找。
C语言图数据结构之拓扑排序实现方法
在C语言中实现图时，通常会使用邻接矩阵或邻接表这两种数据结构。邻接矩阵用二维数组表示图中的边，而邻接表则用链表表示每个顶点的邻接顶点。在拓扑排序中，因为需要表示顶点之间的依赖关系，通常采用有向图。 ###...
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值