【简单实用框架】【十大排序算法直接调用】【可移植】

已于 2023-05-30 16:52:28 修改
阅读量966 收藏 3
点赞数 1
分类专栏： Unity实用框架 文章标签： 开发语言 unity 排序算法 算法
于 2023-05-30 16:41:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42555291/article/details/130951741
版权

  • ☀️博客主页：CSDN博客主页
  • 💨本文由 萌萌的小木屋 原创，首发于 CSDN💢
  • 🔥学习专栏推荐：面试汇总
  • ❗️游戏框架专栏推荐：游戏实用框架专栏
  • ⛅️点赞 👍 收藏 ⭐留言 📝，如有错误请指正

  • 📆 未来很长，值得我们全力奔赴更美好的生活✨

  • ------------------❤️分割线❤️-------------------------

请添加图片描述​​​请添加图片描述​​​请添加图片描述​​​

​​​

 Unity 小科普

老规矩，先介绍一下Unity的科普小知识：​​​

  •  Unity 是行业领先的实时3D开发平台。
  • 包括游戏开发，电影，AR/VR，虚拟现实在内的所有创作者，可以将梦想照进现实。
  • Unity提供了一套完整完善的软件解决方案，可用于创作，运营和模拟任何2D和3D的内容，进本全平台支持。
  • 实际上Unity就是一个游戏引擎，大名鼎鼎的原神就是用它制作的。

MGameFrame：慢慢积累的属于自己的框架

目的：自己工作期间凭当前水准自己写的代码框架，持续更新中，方便以后自己使用，现在开源，需要自取

需求：工程中，经常会使用到排序函数，但是每次去搜索，可能最常见的就是冒泡排序，现自己总结了所有的排序，方便自己在工程中快速的使用

十大排序

冒泡，插入，归并，桶，基数，二叉树，选择，希尔，堆，快速

参考链接

参考学习

注意事项

可以直接复制源码，也可以从我的GitCode中自取

源码

using System;
using System.Collections.Generic;
public class SortTool
{
    //整体参考：https://blog.csdn.net/weixin_43199474/article/details/93067441?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522167782546316800215039843%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=167782546316800215039843&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-1-93067441-null-null.142^v73^insert_down2,201^v4^add_ask,239^v2^insert_chatgpt&utm_term=%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95%E5%8F%8A%E5%85%B6%E5%A4%8D%E6%9D%82%E5%BA%A6&spm=1018.2226.3001.4187

    #region 冒泡排序
    /// <summary>
    /// 冒泡排序（优化版本）
    /// 时间复杂度:最差：O(n^2)，最好O(n)
    /// 空间复杂度:O(1)
    /// https://blog.csdn.net/qq_48718409/article/details/120866840?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522167782824716800222841549%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=167782824716800222841549&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-1-120866840-null-null.142^v73^insert_down2,201^v4^add_ask,239^v2^insert_chatgpt&utm_term=%E6%8F%92%E5%85%A5%E6%8E%92%E5%BA%8F%E5%AE%9E%E7%8E%B0&spm=1018.2226.3001.4187
    /// </summary>
    /// <param name="list"></param>
    public static void BubbleSort(List<int> list)
    {
        bool flag = false;
        for (int i = 0; i < list.Count - 1; i++)
        {
            flag = false;
            for (int j = 0; j < list.Count - 1 - i; j++)
            {
                if (list[j] > list[j + 1])
                {
                    int temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = list[j];
                    flag = true;
                }
            }
            if (flag == false)
            {
                break;
            }
        }
    }
    #endregion

    #region 插入排序
    /// <summary>
    /// 插入排序
    /// 时间复杂度:最差：O(n^2)，最好O(n)
    /// 空间复杂度:O(1)
    /// https://blog.csdn.net/qq_48718409/article/details/120866840?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522167782824716800222841549%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=167782824716800222841549&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-1-120866840-null-null.142^v73^insert_down2,201^v4^add_ask,239^v2^insert_chatgpt&utm_term=%E6%8F%92%E5%85%A5%E6%8E%92%E5%BA%8F%E5%AE%9E%E7%8E%B0&spm=1018.2226.3001.4187
    /// </summary>
    /// <param name="list"></param>
    public static void InsertSort(List<int> list)
    {
        for (int i = 1; i < list.Count; i++)
        { //控制循环轮数
            int temp = list[i]; //定义待交换元素
            int j; //定义待插入的位置
            for (j = i; j > 0 && temp < list[j - 1]; j--)
            {
                list[j] = list[j - 1];
            }
            list[j] = temp;
        }
    }
    #endregion 

    #region 归并排序
    /// <summary>
    /// 归并排序
    /// 时间复杂度:O(nlog(n))
    /// 空间复杂度:O(n)</summary>
    /// https://www.cnblogs.com/chengxiao/p/6194356.html
    /// <param name="list"></param>
    public static void MergerSort(List<int> list)
    {
        int[] temp = new int[list.Count];//在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        sort(list, 0, list.Count - 1, temp);
    }

    private static void sort(List<int> list, int left, int right, int[] temp)
    {
        if (left < right)
        {
            int mid = (left + right) / 2;
            sort(list, left, mid, temp);//左边归并排序，使得左子序列有序
            sort(list, mid + 1, right, temp);//右边归并排序，使得右子序列有序
            merge(list, left, mid, right, temp);//将两个有序子数组合并操作
        }
    }

    private static void merge(List<int> list, int left, int mid, int right, int[] temp)
    {
        int i = left;//左序列指针
        int j = mid + 1;//右序列指针
        int t = 0;//临时数组指针
        while (i <= mid && j <= right)
        {
            if (list[i] <= list[j])
            {
                temp[t++] = list[i++];
            }
            else
            {
                temp[t++] = list[j++];
            }
        }
        while (i <= mid)
        {//将左边剩余元素填充进temp中
            temp[t++] = list[i++];
        }
        while (j <= right)
        {//将右序列剩余元素填充进temp中
            temp[t++] = list[j++];
        }
        t = 0;
        //将temp中的元素全部拷贝到原数组中
        while (left <= right)
        {
            list[left++] = temp[t++];
        }
    }
    #endregion

    #region 桶排序
    /// <summary>
    /// 归并排序
    /// 时间复杂度:O(N+M)，近似O(N)
    /// 空间复杂度:O(N+M)
    /// https://www.cnblogs.com/skywang12345/p/3602737.html
    /// </summary>
    /// <param name="list"></param>
    public static void BucketSort(List<int> list, int maxVal)
    {
        int[] buckets;

        if (list == null || maxVal < 1)
            return;

        // 创建一个容量为max的数组buckets，并且将buckets中的所有数据都初始化为0。
        buckets = new int[maxVal];

        // 1. 计数
        for (int i = 0; i < list.Count; i++)
            buckets[list[i]]++;

        // 2. 排序
        for (int i = 0, j = 0; i < maxVal; i++)
        {
            while ((buckets[i]--) > 0)
            {
                list[j++] = i;
            }
        }

        buckets = null;
    }
    #endregion

    #region 基数排序
    /// <summary>
    /// 基数排序
    /// 时间复杂度:O( k*n ) ；其中k为常数，n为元素个数；
    /// 空间复杂度:（10 × length）= O （length）
    /// https://www.cnblogs.com/skywang12345/p/3603669.html
    /// </summary>
    /// <param name="list"></param>
    public static void RadixSort(List<int> list)
    {
        int exp;    // 指数。当对数组按各位进行排序时，exp=1；按十位进行排序时，exp=10；...
        int max = getMax(list);    // 数组a中的最大值

        // 从个位开始，对数组a按"指数"进行排序
        for (exp = 1; max / exp > 0; exp *= 10)
            countSort(list, exp);
    }

    /// <summary>
    /// 获取数组a中最大值
    /// </summary>
    /// <param name="list"></param>
    /// <returns></returns>
    private static int getMax(List<int> list)
    {
        int mlistx;

        mlistx = list[0];
        for (int i = 1; i < list.Count; i++)
            if (list[i] > mlistx)
                mlistx = list[i];
        return mlistx;
    }

    /*
     * 对数组按照"某个位数"进行排序(桶排序)
     *
     * 参数说明：
     *     a -- 数组
     *     exp -- 指数。对数组a按照该指数进行排序。
     *
     * 例如，对于数组a={50, 3, 542, 745, 2014, 154, 63, 616}；
     *    (01) 当exp=1表示按照"个位"对数组a进行排序
     *    (02) 当exp=10表示按照"十位"对数组a进行排序
     *    (03) 当exp=100表示按照"百位"对数组a进行排序
     *    ...
     */
    private static void countSort(List<int> list, int exp)
    {
        //int output[list.length];    // 存储"被排序数据"的临时数组
        int[] output = new int[list.Count];    // 存储"被排序数据"的临时数组
        int[] buckets = new int[10];

        // 将数据出现的次数存储在buckets[]中
        for (int i = 0; i < list.Count; i++)
            buckets[(list[i] / exp) % 10]++;

        // 更改buckets[i]。目的是让更改后的buckets[i]的值，是该数据在output[]中的位置。
        for (int i = 1; i < 10; i++)
            buckets[i] += buckets[i - 1];

        // 将数据存储到临时数组output[]中
        for (int i = list.Count - 1; i >= 0; i--)
        {
            output[buckets[(list[i] / exp) % 10] - 1] = list[i];
            buckets[(list[i] / exp) % 10]--;
        }

        // 将排序好的数据赋值给list[]
        for (int i = 0; i < list.Count; i++)
            list[i] = output[i];

        output = null;
        buckets = null;
    }
    #endregion

    #region 二叉树排序
    //待更新
    #endregion

    #region 选择排序
    /// <summary>
    /// 选择排序
    /// 时间复杂度:O(N^2)
    /// 空间复杂度:O(N^2)
    /// https://blog.csdn.net/zhuo_wp/article/details/78223481?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522167783001016800213086400%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=167783001016800213086400&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-78223481-null-null.142^v73^insert_down2,201^v4^add_ask,239^v2^insert_chatgpt&utm_term=C%23%20%E9%80%89%E6%8B%A9%E6%8E%92%E5%BA%8F&spm=1018.2226.3001.4187
    /// </summary>
    /// <param name="list"></param>
    public static void SelectionSort(int[] array)
    {
        for (int i = 0; i < array.Length - 1; i++)
        {
            int minValueIndex = i;
            for (int j = i + 1; j < array.Length; j++)
            {
                if (array[minValueIndex] > array[j])
                {
                    minValueIndex = j;
                }
            }

            if (minValueIndex != i)
            {
                Exchange(ref array[i], ref array[minValueIndex]);
            }
        }
    }
    private static void Exchange(ref int x, ref int y)
    {
        int temp = x;
        x = y;
        y = temp;
    }

    private static void Exchange<T>(ref T x, ref T y)
    {
        T temp = x;
        x = y;
        y = temp;
    }
    #endregion

    #region 希尔排序
    /// <summary>
    /// 希尔排序（移动法）:先选择区间在用插入排序
    /// 时间复杂度:O(N^2)
    /// 空间复杂度:O(N^2)
    /// https://www.cnblogs.com/chengxiao/p/6104371.html
    /// </summary>
    /// <param name="list"></param>
    public static void XierSortForMove(List<int> list)
    {
        //增量gap，并逐步缩小增量
        for (int gap = list.Count / 2; gap > 0; gap /= 2)
        {
            //从第gap个元素，逐个对其所在组进行直接插入排序操作
            for (int i = gap; i < list.Count; i++)
            {
                int j = i;
                int temp = list[j];
                if (list[j] < list[j - gap])
                {
                    while (j - gap >= 0 && temp < list[j - gap])
                    {
                        //移动法
                        list[j] = list[j - gap];
                        j -= gap;
                    }
                    list[j] = temp;
                }
            }
        }
    }

    private static void XierSwap(List<int> list, int a, int b)
    {
        list[a] = list[a] + list[b];
        list[b] = list[a] - list[b];
        list[a] = list[a] - list[b];
    }

    /// <summary>
    /// 希尔排序（交换法）:先选择区间在用插入排序
    /// 时间复杂度:O(N^2)
    /// 空间复杂度:
    /// https://www.cnblogs.com/chengxiao/p/6104371.html
    /// </summary>
    /// <param name="list"></param>
    public static void XierSortForSwap(List<int> list)
    {
        //增量gap，并逐步缩小增量
        for (int gap = list.Count / 2; gap > 0; gap /= 2)
        {
            //从第gap个元素，逐个对其所在组进行直接插入排序操作
            for (int i = gap; i < list.Count; i++)
            {
                int j = i;
                while (j - gap >= 0 && list[j] < list[j - gap])
                {
                    //插入排序采用交换法
                    XierSwap(list, j, j - gap);
                    j -= gap;
                }
            }
        }
    }
    #endregion

    #region 堆排序
    /// <summary>
    /// 堆排序
    /// 时间复杂度:O(nlogn)
    /// 空间复杂度:O(1)
    /// https://blog.csdn.net/qq_35552025/article/details/77995524?ops_request_misc=&request_id=&biz_id=102&utm_term=%E5%A0%86%E6%8E%92%E5%BA%8F%20C&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-1-77995524.142^v73^insert_down2,201^v4^add_ask,239^v2^insert_chatgpt&spm=1018.2226.3001.4187#%E5%AE%9E%E7%8E%B0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-1-77995524.142^v73^insert_down2,201^v4^add_ask,239^v2^insert_chatgpt
    /// </summary>
    /// <param name="list"></param>
    public static void HeapSort(List<int> list)
    {
        //将最大的值推到堆顶
        //x根据最后一个子节点的位置计算出父节点
        int x = Convert.ToInt32(Math.Floor(Convert.ToDouble((list.Count - 2) / 2)));
        for (int i = x; i >= 0; i--)
        {
            //如果子元素只存在左子元素是 让右子元素等于左子元素
            while (list[i] < list[i * 2 + 1] || list[i] < list[(i * 2 + 2) > (list.Count - 1) ? (i * 2 + 1) : i * 2 + 2])
            {
                if (list[i * 2 + 1] >= list[(i * 2 + 2) > (list.Count - 1) ? (i * 2 + 1) : i * 2 + 2])
                {
                    int index = list[i];
                    list[i] = list[i * 2 + 1];
                    list[i * 2 + 1] = index;

                }
                else
                {
                    int index = list[i];
                    list[i] = list[i * 2 + 2];
                    list[i * 2 + 2] = index;

                }

            }
        }
        //输出堆顶最大的元素
        int max = list[0];
        list[0] = list[list.Count - 1];
        Console.Write("{0}\t", max);
        //将数组中的最后一个元素删除
        List<int> num = new List<int>(list.Count - 1);
        for (int j = 0; j < list.Count - 1; j++)
        {
            num[j] = list[j];
        }
        Adjust(num);
    }

    public static void Adjust(List<int> list)
    {
        if (list.Count > 1)
        {
            HeapSort(list);
        }
    }
    #endregion

    #region 快速排序
    /// <summary>
    /// 快速排序
    /// 时间复杂度:O(nlogn)
    /// 空间复杂度:O(1)
    /// https://blog.csdn.net/enternalstar/article/details/106932822?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522167783146916800188592132%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=167783146916800188592132&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-106932822-null-null.142^v73^insert_down2,201^v4^add_ask,239^v2^insert_chatgpt&utm_term=C%23%20%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F&spm=1018.2226.3001.4187
    /// </summary>
    /// <param name="list"></param>
    public void QuickSort(List<int> list, int lo, int hi)
    {
        if (lo > hi)//递归退出条件
        {
            return;
        }
        int i = lo;
        int j = hi;
        int temp = list[i];//取得基准数，空出一个位置
        while (i < j)//当i=j时推出，表示temp左边的数都比temp小，右边的数都比temp大
        {
            while (i < j && temp <= list[j])//从后往前找比temp小的数，将比temp小的数往前移
            {
                j--;
            }
            list[i] = list[j];//将比基准数小的数放在空出的位置，j的位置又空了出来
            while (i < j && temp >= list[i])//从前往后找比temp大的数，将比temp大的数往后移
            {
                i++;
            }
            list[j] = list[i];//将比基准数大的数放在hi空出来的位置,如此，i所在的位置又空了出来
        }
        list[i] = temp;
        QuickSort(list, lo, i - 1);//对lo到i-1之间的数再使用快速排序，每次快速排序的结果是找到了基准数应该在的位置
                                //其左边的数都<=它，右边的数都>=它，它此时在数组中的位置就是排序好时其应该在的位置。
        QuickSort(list, i + 1, hi);//对i+1到hi之间的数再使用快速排序
    }
    #endregion
}

GitCode地址

有用点个Fork啊

更新记录

2023-5-30 更新了九个排序静态算法

我是小狼君
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C++排序算法利用EsayX实现过程可视化
qq_46534428的博客
11-10 704
未完工
快速排序
量子小白的博客
10-16 242
// kuaisupaixu.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include<iostream> #include<algorithm>//sort #include<vector> int v[1000000]; using namespace std; int main() { int n, ...
Unity 在list内部交换片段
Ryker的博客
05-28 775
功能实现目标：最近项目中遇到的一个需求，要求在list中索引为index的位置，index后的片段换到前面，index前的移到前面，也就是从index的位置前后交换。 例如：A B C D E F 从索引为3的位置开始交换片段，交换后变为D E F A B C ok,代码实现如下： /// <summary> /// 交换list的某个片段 /// </summary> /// <typeparam name="T"></typeparam&
Unity3D 数组和列表互转
WenHui君_的博客
03-02 5462
Unity3D数组和列表互转 1、数组转列表 GameObject[] G ; List<GameObject> gl = new List<GameObject>(G); 2、列表转数组 List<GameObject> GL = new List<GameObject>(); GameObject[] g = GL.ToArray(); ...
基于easyx的自动排序系统（C语言）
wangenzhe7的博客
10-29 361
基于easy的自动排序交互系统
大一的C语言课程，基础算法示例。.zip
最新发布
06-13
在这个压缩包里，你可能会找到一些基础算法的实现，比如排序算法（冒泡排序、选择排序、插入排序、快速排序等）、查找算法（线性查找、二分查找）、递归函数的应用等。这些算法的实践有助于理解如何用C语言解决实际...
用SSE2实现冒泡排序
04-07
描述中提到的“通用错误算法”可能是指冒泡排序本身，因为尽管它是一种简单的排序算法，但在大量数据下效率较低，常常被视为“错误”的选择。然而，通过SSE2技术，可以利用硬件级别的并行性来加速冒泡排序的过程，...
Algorithms-LeetCode:用Java解决算法问题
03-14
在处理算法问题时，Java提供了丰富的库和工具，如集合框架（包括ArrayList、LinkedList、HashSet、HashMap等）和排序算法（如快速排序、归并排序）。 1. **数组和链表**：数组是最基本的数据结构之一，用于存储同...
交换List集合中任意两个元素的位置
热门推荐
weixin_44488164的博客
02-16 1万+
- 交换List集合中任意两个元素的位置 定义一个方法swap()传入集合和两个角标使集合中元素交换位置 使用创建第三方变量的方式实现两个元素的位置交换 // An highlighted block public static void main(String[] args) { List&lt;String&gt; list=new ArrayList&lt;&gt;(); list.a...
Unity 基础 之 List 作为参数传递的值变化的三种情况注意
仙魁XAN
03-08 2691
Unity 基础 之 List 作为参数传递的值变化的三种情况注意 目录 Unity 基础 之 List 作为参数传递的值变化的三种情况注意 一、简单介绍 二、基本概念 三、三点注意 四、代码示例说明三点注意 1、测试代码 2、运行结果 一、简单介绍 Unity中的一些基础知识点。 本片介绍 List 在作为 参数传递的时候的一些之变化情况。 二、基本概念...
List位置交换，一及只List显示第一个
珍惜现再的专栏
02-02 1896
今天刚刚好做List排序部分，遇到了List位置交换，一及只List显示第一个，研究了下，代码如下： Object objA= list.get(a); list.set(a, list.get(b)); list.set(b, objA); 我一群组第一
在Unity序列化List<>
JousonRen的博客
01-10 5471
在Unity的inspector检视面板中像List这种不会自动序列化的数据结构 在自定义的类或者结构体前加上[System.Serializable] 在自定义的类或者结构体里面的数据前加上[SerializeField]
两个List<Map<String, Object>>之间的数值交换
付梦伟的博客
08-29 3036
List>的赋值。在一个地方我需要重一个List<Map<String, Object>>里的数据循环到并改名到另外一个List>。 List> result = new ArrayList<>(); List> result2 = new ArrayList<>(); result2 = CITService.queryComplianIndexNowDay(); for(int i =
查看SWAP
痴迷无限好
09-27 176
1.查看SWAP [root@192 oc]# cat /proc/swaps Filename Type Size Used Priority /dev/sda3 partition 8024 104 -1 ...
511.Swap Two Nodes in Linked List-交换链表当中两个节点（中等题）
三色旗飞扬
11-19 475
交换链表当中两个节点 题目给你一个链表以及两个权值v1和v2，交换链表中权值为v1和v2的这两个节点。保证链表中节点权值各不相同，如果没有找到对应节点，那么什么也不用做。注意事项 你需要交换两个节点而不是改变节点的权值 样例给出链表 1->2->3->4->null ，以及 v1 = 2 ， v2 = 4 返回结果 1->4->3->2->null。 题解基本的链表题，需注意两个节点相邻的问题
Unity换装实现
songchao_xx的博客
07-29 6069
最近整理了一下项目的换装系统，有一些想法，在这里分享一下。 我们的角色拆分了四个部件，头发，身体，腿和脚，对应到gameobject是这样的，000是骨骼根节点。 装备导出是这样的，skinnedmeshrenderer在000同级的子节点上，装备导出也是带骨骼信息的。 第一种实现办法 把装备gameobject挂到角色根节点下，然后通过setactive设置原部件和装备的显隐。 ...
十大经典排序算法详解：冒泡排序、选择排序等
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

我是小狼君

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

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

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

打赏作者

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

抵扣说明：

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

余额充值