插入排序、冒泡排序、选择排序、希尔排序、高速排序、归并排序、堆排序和LST基数排序——C++实现...

最新推荐文章于 2024-11-09 13:08:09 发布
最新推荐文章于 2024-11-09 13:08:09 发布
阅读量99 收藏
点赞数
文章标签： c/c++ java 数据结构与算法

首先是算法实现文件Sort.h。代码例如以下：

<pre name="code" class="java">/*
* 实现了八个经常使用的排序算法：插入排序、冒泡排序、选择排序、希尔排序
* 以及高速排序、归并排序、堆排序和LST基数排序
* @author gkh178
*/
#include <iostream>

template<class T>
void swap_value(T &a, T &b)
{
	T temp = a;
	a = b;
	b = temp;
}

//插入排序：时间复杂度o(n^2)
template<class T>
void insert_sort(T a[], int n)
{
	for (int i = 1; i < n; ++i)
	{
		T temp = a[i];
		int j = i - 1;
		while (j >= 0 && a[j] > temp)
		{
			a[j + 1] = a[j];
			--j;
		}
		a[j + 1] = temp;
	}
}

//冒泡排序：时间复杂度o(n^2) 
template<class T>
void bubble_sort(T a[], int n)
{
	for (int i = n - 1; i > 0; --i)
	{
		for (int j = 0; j < i; ++j)
		{
			if (a[j] > a[j + 1])
			{
				swap_value(a[j], a[j + 1]);
			}
		}
	}
}

//选择排序：时间复杂度o(n^2)
template<class T>
void select_sort(T a[], int n)
{
	for (int i = 0; i < n - 1; ++i)
	{
		T min = a[i];
		int index = i;
		for (int j = i + 1; j < n; ++j)
		{
			if (a[j] < min)
			{
				min = a[j];
				index = j;
			}
		}
		a[index] = a[i];
		a[i] = min;
	}
}

//希尔排序：时间复杂度介于o(n^2)和o(nlgn)之间 
template<class T>
void shell_sort(T a[], int n)
{
	for (int gap = n / 2; gap >= 1; gap /= 2)
	{
		for (int i = gap; i < n; ++i)
		{
			T temp = a[i];
			int j = i - gap;
			while (j >= 0 && a[j] > temp)
			{
				a[j + gap] = a[j];
				j -= gap;
			}
			a[j + gap] = temp;
		}
	}
}

//高速排序：时间复杂度o(nlgn)  
template<class T>
void quick_sort(T a[], int n)
{
	_quick_sort(a, 0, n - 1);
}
template<class T>
void _quick_sort(T a[], int left, int right)
{
	if (left < right)
	{
		int q = _partition(a, left, right);//一次划分得到的中位数的位置
		_quick_sort(a, left, q - 1);//对左边进行递归快排
		_quick_sort(a, q + 1, right);//对右边进行递归快排
	}
}
template<class T>
int _partition(T a[], int left, int right)
{
	T pivot = a[left];//设置第一个数为中位数
	while (left < right)
	{
		while (left < right && a[right] >= pivot)
		{
			--right;
		}
		a[left] = a[right];//从右到左寻找一个比中位数小的数。将其填入中位数的所在位置
		while (left < right && a[left] <= pivot)
		{
			++left;
		}
		a[right] = a[left];//从左到右寻找一个比中位数大的数，将其填入刚才空缺的位置
	}
	a[left] = pivot;//将中位数填入空缺位置
	return left;
}

//归并排序：时间复杂度o(nlgn)  
template<class T>
void merge_sort(T a[], int n)
{
	_merge_sort(a, 0, n - 1);
}
template<class T>
void _merge_sort(T a[], int left, int right)
{
	if (left < right)
	{
		int mid = left + (right - left) / 2;
		_merge_sort(a, left, mid);//对左边递归归并排序
		_merge_sort(a, mid + 1, right);//对右边递归归并排序
		_merge(a, left, mid, right);//将左右归并起来
	}
}
template<class T>
void _merge(T a[], int left, int mid, int right)
{
	int length = right - left + 1;
	T *newA = new T[length];//用来暂存原始数组
	for (int i = 0, j = left; i <= length - 1; ++i, ++j)
	{
		*(newA + i) = a[j];
	}
	int i = 0;
	int j = mid - left + 1;
	int k = left;
	for (; i <= mid - left && j <= length - 1; ++k)
	{
		if (*(newA + i) < *(newA + j))
		{
			a[k] = *(newA + i);
			++i;
		}
		else
		{
			a[k] = *(newA + j);
			++j;
		}
	}
	//将左边或者右边多余的数填入数组
	while (i <= mid - left)
	{
		a[k++] = *(newA + i);
		++i;
	}
	while (j <= right - left)
	{
		a[k++] = *(newA + j);
		++j;
	}
	delete[] newA;
}

//堆排序：时间复杂度o(nlgn) 
template<class T>
void heap_sort(T a[], int n)
{
	built_max_heap(a, n);//建立初始大根堆  
	//交换首尾元素。并对交换后排除尾元素的数组进行一次上调整  
	for (int i = n - 1; i >= 1; --i)
	{
		swap_value(a[0], a[i]);
		up_adjust(a, i);
	}
}
//建立一个长度为n的大根堆  
template<class T>
void built_max_heap(T a[], int n)
{
	up_adjust(a, n);
}
//对长度为n的数组进行一次上调整  
template<class T>
void up_adjust(T a[], int n)
{
	//对每一个带有子女节点的元素遍历处理，从后到根节点位置  
	for (int i = n / 2; i >= 1; --i)
	{
		adjust_node(a, n, i);
	}
}
//调整序号为i的节点的值  
template<class T>
void adjust_node(T a[], int n, int i)
{
	//节点有左右孩子  
	if (2 * i + 1 <= n)
	{
		//右孩子的值大于节点的值，交换它们  
		if (a[2 * i] > a[i - 1])
		{
			swap_value(a[2 * i], a[i - 1]);
		}
		//左孩子的值大于节点的值。交换它们  
		if (a[2 * i - 1] > a[i - 1])
		{
			swap_value(a[2 * i - 1], a[i - 1]);
		}
		//对节点的左右孩子的根节点进行调整  
		adjust_node(a, n, 2 * i);
		adjust_node(a, n, 2 * i + 1);
	}
	//节点仅仅有左孩子，为最后一个有左右孩子的节点  
	else if (2 * i == n)
	{
		//左孩子的值大于节点的值，交换它们  
		if (a[2 * i - 1] > a[i - 1])
		{
			swap_value(a[2 * i - 1], a[i - 1]);
		}
	}
}

//基数排序的时间复杂度为o(distance(n+radix)),distance为位数。n为数组个数，radix为基数  
//本方法是用LST方法进行基数排序。MST方法不包括在内  
//当中參数radix为基数，一般为10。distance表示待排序的数组的数字最长的位数。n为数组的长度 
template<class T>
void lst_radix_sort(T a[], int n, int radix, int distance)
{
	T* newA = new T[n];//用于暂存数组  
	int* count = new int[radix];//用于计数排序。保存的是当前位的值为0 到 radix-1的元素出现的的个数  
	int divide = 1;
	//从倒数第一位处理到第一位  
	for (int i = 0; i < distance; ++i)
	{
		//待排数组复制到newA数组中
		for (int j = 0; j < n; ++j)
		{
			*(newA + j) = a[j];
		}
		//将计数数组置0  
		for (int j = 0; j < radix; ++j)
		{
			*(count + j) = 0;
		}
		for (int j = 0; j < n; ++j)
		{
			int radixKey = (*(newA + j) / divide) % radix; //得到数组元素的当前处理位的值  
			(*(count + radixKey))++;
		}
		//此时count[]中每一个元素保存的是radixKey位出现的次数  
		//计算每一个radixKey在数组中的结束位置。位置序号范围为1-n  
		for (int j = 1; j < radix; ++j)
		{
			*(count + j) = *(count + j) + *(count + j - 1);
		}
		//运用计数排序的原理实现一次排序，排序后的数组输出到a[]  
		for (int j = n - 1; j >= 0; --j)
		{
			int radixKey = (*(newA + j) / divide) % radix;
			a[*(count + radixKey) - 1] = newA[j];
			--(*(count + radixKey));
		}
		divide = divide * radix;
	}
	delete[] newA;
	delete[] count;
}


 
  
 然后是測试文件main.cpp。代码例如以下： 
  
 
  
 
  
#include "Sort.h"
using namespace std;

template<class T>
void printArray(T a[], int n)
{
	for (int i = 0; i < n; ++i)
	{
		cout << a[i] << " ";
	}
	cout << endl;
}

int main()
{
	for (int i = 1; i <= 8; ++i)
	{
		int arr[] = { 45, 38, 26, 77, 128, 38, 25, 444, 61, 153, 9999, 1012, 43, 128 };
		switch (i)
		{
		case 1:
			insert_sort(arr, sizeof(arr) / sizeof(arr[0]));
			break;
		case 2:
			bubble_sort(arr, sizeof(arr) / sizeof(arr[0]));
			break;
		case 3:
			select_sort(arr, sizeof(arr) / sizeof(arr[0]));
			break;
		case 4:
			shell_sort(arr, sizeof(arr) / sizeof(arr[0]));
			break;
		case 5:
			quick_sort(arr, sizeof(arr) / sizeof(arr[0]));
			break;
		case 6:
			merge_sort(arr, sizeof(arr) / sizeof(arr[0]));
			break;
		case 7:
			heap_sort(arr, sizeof(arr) / sizeof(arr[0]));
			break;
		case 8:
			lst_radix_sort(arr, sizeof(arr) / sizeof(arr[0]), 10, 4);
			break;
		default:
			break;
		}
		printArray(arr, sizeof(arr) / sizeof(arr[0]));
	}
	return 0;
}
 
  
 最后是执行结果图，例如以下： 
  
 
  

 
  

 
 
 


                

        

        




    

  


            

                    
            

    

      

        

            

              
                
                  weixin_34195142
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
冒泡排序 ，选择排序，插入排序，归并排序，快速排序，希尔排序，堆排序，计数排序，桶排序，基数排序的 C++实现

				
			

			

				

					天天向上
				

				

					04-01
					
					525
					
				

			

		

		

			
				
文章目录冒泡排序 O(n*n)选择排序 O(n*n)归并排序 O(nlogN)快速排序排序
冒泡排序 O(n*n)
算法思路
两两比较，将两者较少的升上去，第一次比较下标范围为0到(N-1)，最后一轮比较空间为0到1
算法实现
可以看到，在此次运行中，把一万个数据排序，需要花674ms。
//冒泡排序 
#include<iostream>  
#include<time.h>
#include <iomanip>
#include<stdlib.h> 
us

			
		

	



                

            
              



	

		

			

				
					
十大排序算法及其实现（C++ & Python）

				
			

			

				

					大树先生的博客
				

				

					04-16
					
					4124
					
				

			

		

		

			
				
冒泡排序、插入排序、shell排序、选择排序、快速排序、归并排序 、堆排序、计数排序、桶排序、基数排序

			
		

	



              


  
              

                


	

		

			

				
					
7种常用排序算法实现（C++）（冒泡排序、选择排序、直接插入排序、希尔排序、堆排序、归并排序以及快速排序）

				
			

			

				

					04-11
				

			

		

		

			
				
本文件是7种常用排序算法的实现（C++），包括冒泡排序、选择排序、直接插入排序、希尔排序、堆排序、归并排序以及快速排序。代码详细有注释且有测试用例。

			
		

	





	

		

			

				
					
插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序——JAVA实现

				
			

			

				

					小三哥的随手记
				

				

					07-30
					
					1479
					
				

			

		

		

			
				
首先是EightAlgorithms.java文件，代码如下：
import java.util.Arrays;
/*
 * 实现了八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序
 * 以及快速排序、归并排序、堆排序和LST基数排序
 * @author gkh178
 */
public class EightAlgorithms {
	
	//插入排序：时间复杂度o(n^2)

			
		

	



		

			
		



	

		

			

				
					
基数排序详解

				
			

			

				

					xuuyann
				

				

					11-30
					
					4442
					
				

			

		

		

			
				
基数排序
写在前头(〃‘▽’〃)

基数排序时桶排序的一种推广（桶排序详解），它所考虑的待排记录包含不止一个关键字。例如对一副牌进行整理，可将每张牌看做一个记录，包含两个关键字：花色、面值。一副理顺的牌是按如下顺序进行排放的：

可见一个有序结果是先按花色划分成四大块，每一块中有按面值大小排序。这是“花色”就是一张牌的“最主位关键字”，而“面值”是“最次位关键字”。
对于一般有K个关键字的情况，基...

			
		

	





	

		

			

				
					
数据结构基础(15)  --基数排序

				
			

			

				

					weixin_30511107的博客
				

				

					01-11
					
					474
					
				

			

		

		

			
				
基数排序是一种借助“多关键字排序”的思想来实现“单关键字排序”的内部排序算法。实现多关键字排序通常有两种作法: 最低位优先法(LSD)  先对K[0]{基数的最低位}进行排序，并按K(0)的不同值将记录序列分成若干子序列之后，分别对K[1]进行排序,...,K[d-1]依次类推，直至最后对最次位关键字排序完成为止。 最高位优先法(MSD)  先对K[d-1]{...

			
		

	





	

		

			

				
					
插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序——C++实现

				
			

			

				

					小三哥的随手记
				

				

					07-31
					
					1924
					
				

			

		

		

			
				
首先是算法实现文件Sort.h，代码如下：
/*
* 实现了八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序
* 以及快速排序、归并排序、堆排序和LST基数排序
* @author gkh178
*/
#include 

template
void swap_value(T &a, T &b)
{
	T temp = a;
	a = b;
	b = temp;
}

//插入排序：时

			
		

	





	

		

			

				
					
C++实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等

				
			

			

				

					09-03
				

			

		

		

			
				
在本文中，我们将深入探讨C++实现的八种常见的排序算法，它们分别是插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序。这些排序算法在计算机科学中有着广泛的应用，是理解和掌握...

			
		

	





	

		

			

				
					
C++实现冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序、快速排序

				
			

			

				

					weixin_44520881的博客
				

				

					07-07
					
					950
					
				

			

		

		

			
				
总结记录一下，C++实现各种排序算法，加深理解。参考《大话数据结构》

			
		

	





	

		

			

				
					
C++实现八大经典排序算法详解与代码示例

				
			

			

				

					
				

			

		

		

			
				
本文详细介绍了如何在C++中实现八个常见的排序算法，包括插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序以及LST基数排序。这些排序算法在计算机科学中具有重要的地位，它们在数据处理、数据...

			
		

	





	

		

			

				
					
基数排序(最低位优先法)-对于十进制基数则为10(局限性-对于具有固定位数的键值排序)

				
			

			

				

					家里蹲大学摸鱼学专业优秀毕业生的博客
				

				

					01-22
					
					1195
					
				

			

		

		

			
				
基数排序针对具有固定位数的序列十分有效。
比如以下序列：
T array[10] = {165,993,278,756,643,853,697,503,972,229};
它的具体排序规则就是最低位优先法。
你不需要具体了解该算法背后的理论，其实理论真的很晦涩。
它的思想就是分配排序。
基数排序是利用一种最低位优先法的单关键值排序方法，这里的"位"就是单关键字中的一个分量。
比如以上未排序序列：
T array[10] = {165,993,278,756,643,853,697,503,972,229};

			
		

	





	

		

			

				
					
内部排序算法合集（插入、希尔、起泡、快速、选择、堆、归并和基数排序）

				
			

			

				

					01-21
				

			

		

		

			
				
内部排序合集（插入、希尔、起泡、快速、选择、堆、归并和基数排序）
	这是我在我们期末的时候写的一些内部排序的例子。因为我们的数据结构考试的范围就限定在内部排序上，所以我没有什么办法，只好对自己埋头苦干就行内部排序的编程了。有些内部排序的例子很是好理解，我们可以通过一些图示来很好地了解到这些排序的过程，但是这些程序的代码可能不是那么好写。而另外一些程序的思想既难以理解，也难于编码。着实地伤透了我的脑筋。下面就将我的程序的主框架代码展示给大家看看。注意，在这里我怎样也不好实现2-路插入排序，因为它这样的排序方法运用在顺序存储结构下不好，在判断数组越界的时候这样的复杂性使我最终放弃了这种方法。要不还不如使用其余的排序呢。
	毕竟了解内部排序是一件好事，以后在看一些内部排序的时候也不至于摸不着头脑。最近我看到了一本有关介绍用C++来编辑游戏的书，它就以STL为例，讲解了STL内部实现的机理。
// 头文件
#include 
using namespace std;

#include "InsertionSort.h"
#include "Shell'sSort.h"
#include "QuickSort.h"
#include "SelectionSort.h"
#include "MergingSort.h"
#include "RadixSort.h"

// 定义的宏
#define LENGTH		10

// 主函数
int main( int argc, char** argv )
{
	// 定义一个顺序表
	SqList a;
	int objArray[LENGTH] = { 278, 109, 63, 930, 589, 184, 505, 269, 8, 83 };
	a.length = LENGTH;
	int i;
	for ( i = 1; i < a.length + 1; i++ )// 需要将0号位设为监视哨
	{
		a.r[i].key = objArray[i-1];
		a.r[i].otherinfo = '\0';
	}

	// 直接插入排序
	//InsertSort( a );

	// 折半插入排序
	//BInsertSort( a );

	// 2-路插入排序
	//BinRouteInsertSort( a, 2 );// 这个算法有问题

	// 希尔排序
	/*
	{
	int dlta2[3] = { 3, 2, 1 };
	ShellSort( a, dlta2, 3 );
	}
	*/

	// 起泡排序
	//BubbleSort( a );

	// 快速排序
	//QuickSort( a, 1, LENGTH );

	// 选择排序
	//SelectSort( a );

	// 堆排序
	//HeapSort( a );

	// 归并排序
	//MergeSort( a );

	// 基数排序
	{
		SLList b;
		int i;

		b.keynum = 3, b.recnum = LENGTH;// 对3位整数进行基数排序
		for ( i = 1; i <= b.recnum; i++ )
		{
			b.r[i].keys[0] = objArray[i-1] % 10;// 个位
			b.r[i].keys[1] = objArray[i-1] % 100 / 10;// 十位
			b.r[i].keys[2] = objArray[i-1] / 100;// 百位
		}
		RadixSort( b );
	}

	// 显示排序后的数组
	for ( i = 1; i < a.length + 1; i++ )// 需要将0号位设为监视哨
		cout<<a.r[i].key<<' ';
	cout<<'\n';

	return 0;
}
	
	要想得到这些排序的具体实现，那么就下载我的代码吧。最近我的积分由于下载一些Boost的资料而变为0了。所以需要的朋友一定要支持一下哦。（使用VS2005开发，算法都是C风格的，可以直接使用。）

	我最新的动态：最近在研究DirectInput，希望能够在几天后写一篇技术文章，分享一些我的经验。

			
		

	





	

		

			

				
					
python做数据排序_基于python进行桶排序与基数排序的总结

				
			

			

				

					weixin_39823299的博客
				

				

					12-10
					
					93
					
				

			

		

		

			
				
本文首先举例阐述了两种排序方法的操作步骤，然后列出了用python进行的实现过程，最后对桶式排序方法的优劣进行了简单总结。一、桶排序：排序一个数组[5,3,6,1,2,7,5,10]值都在1-10之间，建立10个桶：[0 0 0 0 0 0 0 0 0 0] 桶[1 2 3 4 5 6 7 8 9 10] 桶代表的值遍历数组，第一个数字5，第五个桶加1[0 0 0 0 1 0 0 0 0 0]第二...

			
		

	





	

		

			

				
					
python每日算法 | 基数排序PK快速排序，手撕基数排序算法！

				
			

			

				

					REPCHAOCHAO的博客
				

				

					09-07
					
					765
					
				

			

		

		

			
				
python每日算法9.7：十大排序算法之基数排序，通过本期内容你将掌握基数排序如何用python实现，以及基数排序与快速排序的效率比较。

			
		

	





	

		

			

				
					
C++实现冒泡排序、快速排序和归并排序

				
			

			

				

					li_jia_tu的博客
				

				

					08-28
					
					470
					
				

			

		

		

			
				
1.冒泡排序
#include <ioatream>
#include <vector>
#include <algorithm>
void bubbleSort(std::vector<int> &vec)
{
 for (size_t i = 0;i+1 < vec.size();++i) {
  for (size_t j = 0...

			
		

	





	

		

			

				
					
查找与排序

				
			

			

				

					XiaoFengsen的博客
				

				

					03-20
					
					1621
					
				

			

		

		

			
				
查找与排序二分查找排序与Lambda 表达式
二分查找
有序数组或对时间复杂度的要求有 log，通常用二分查找。
基本思路是每次取中间，如果等于目标即返回，否则根据大小关系切去一半，时间复杂度是O(logn)，空间复杂度O(1)。0
704. 二分查找
35. 搜索插入位置
【题目描述】给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。
解答：
int searchInsert(vect

			
		

	





	

		

			

				
					
flex与Bison 词法语法分析

				
			

			

				

					
				

				

					11-06
					
					222
					
				

			

		

		

			
				
编译原理-词法分析实践(flex)_flex编译原理-CSDN博客

			
		

	





	

		

			

				
					
C++_用 using 语句继承基类的构造函数

					
最新发布

				
			

			

				

					学海无涯
				

				

					11-09
					
					94
					
				

			

		

		

			
				
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。

			
		

	





	

		

			

				
					
常用的c++特性--＞day02

				
			

			

				

					m0_69093426的博客
				

				

					11-06
					
					552
					
				

			

		

		

			
				
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。

			
		

	





	

		

			

				
					
GitLab 提交 C++ 技巧

				
			

			

				

					nbspzs的专栏
				

				

					11-08
					
					221
					
				

			

		

		

			
				
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值