O(n*logn)级别的算法之二快速排序的三种实现方法详解及其与归并排序的对比

分类：算法作者：编程之家用户

一，单路快排
1.测试用例：

 1 #ifndef INC_06_QUICK_SORT_DEAL_WITH_NEARLY_ORDERED_ARRAY_SORTTESTHELPER_H
 2 #define INC_06_QUICK_SORT_DEAL_WITH_NEARLY_ORDERED_ARRAY_SORTTESTHELPER_H
 3 #include <iostream>
 4 #include <algorithm>
 5 #include <string>
 6 #include <ctime>
 7 #include <cassert>
 8 using namespace std;
 9  SortTestHelper {
10     // 生成有n个元素的随机数组,每个元素的随机范围为[rangeL,rangeR]
11     int *generateRandomArray(int n,int range_l,1)">int range_r) {
12         int *arr = new [n];
13         srand(time(NULL));
14         for (int i = 0; i < n; i++)
15             arr[i] = rand() % (range_r - range_l + 1) + range_l;
16         return arr;
17     }
18      生成一个近乎有序的数组
19      首先生成一个含有[0...n-1]的完全有序数组,之后随机交换swapTimes对数据
20      swapTimes定义了数组的无序程度
21     int *generateNearlyOrderedArray( swapTimes){
22         23         for(0 ; i < n ; i ++ )
24             arr[i] = i;
25 26         for( 0 ; i < swapTimes ; i ++ ){
27             int posx = rand()%n;
28             int posy = rand()%29             swap( arr[posx],arr[posy] );
30         }
31         32 33      拷贝整型数组a中的所有元素到一个新的数组,并返回新的数组
34     int *copyIntArray(int a[],1)"> n){
35         36         copy(a,a+n,arr);
37         38 39      打印arr数组的所有内容
40     template<typename T>
41     void printArray(T arr[],1)"> n) {
42         43             cout << arr[i] << " ";
44         cout << endl;
45 
46         47 48      判断arr数组是否有序
49     template<typename T>
50     bool isSorted(T arr[],1)">51         0; i < n - 1; i++52             if (arr[i] > arr[i + 1])
53                 return false54         true55 56      测试sort排序算法排序arr数组所得到结果的正确性和算法运行时间
57     template<typename T>
58     void testSort(const string &sortName,1)">void (*sort)(T[],1)">int),T arr[],1)">59         clock_t startTime = clock();
60         sort(arr,n);
61         clock_t endTime =62         cout << sortName << " : " << double(endTime - startTime) / CLOCKS_PER_SEC <<  s"<<endl;
63         assert(isSorted(arr,n));
64         65 66 };
67 #endif

2.归并排序：

#ifndef INC_06_QUICK_SORT_DEAL_WITH_NEARLY_ORDERED_ARRAY_MERGESORT_H
#define INC_06_QUICK_SORT_DEAL_WITH_NEARLY_ORDERED_ARRAY_MERGESORT_H
 5 #include InsertionSort.h"
 6  7  将arr[l...mid]和arr[mid+1...r]两部分进行归并
 8 template<typename  T>
void __merge(T arr[],1)">int l,1)">int mid,1)"> r){
10     T aux[r-l+];
T *aux = new T[r-l+1];
12     int i = l ; i <= r; i ++13         aux[i-l] = arr[i];
14      初始化，i指向左半部分的起始索引位置l；j指向右半部分起始索引位置mid+1
15     int i = l,j = mid+16     int k = l ; k <= r; k ++17         if( i > mid ){   如果左半部分元素已经全部处理完毕
18             arr[k] = aux[j-l]; j ++19 20         else if( j > r ){   如果右半部分元素已经全部处理完毕
21             arr[k] = aux[i-l]; i ++22 if( aux[i-l] < aux[j-l] ) {   左半部分所指元素 < 右半部分所指元素
24             arr[k] = aux[i-l]; i ++else{   左半部分所指元素 >= 右半部分所指元素
27             arr[k] = aux[j-l]; j ++28 30     delete[] aux;
31 }
 使用优化的归并排序算法,对arr[l...r]的范围进行排序
33 template<typename T>
34 void __mergeSort(T arr[],1)">35      对于小规模数组,使用插入排序
36     if( r - l <= 1537         insertionSort(arr,l,r);
38         39 40     int mid = (l+r)/241     __mergeSort(arr,mid);
42     __mergeSort(arr,mid+,1)">43      对于arr[mid] <= arr[mid+1]的情况,不进行merge
44      对于近乎有序的数组非常有效,但是对于一般情况,有一定的性能损失
45     if( arr[mid] > arr[mid+] )
46         __merge(arr,mid,1)">48 template<typename T>
49 void mergeSort(T arr[],1)">50     __mergeSort( arr,0,n- );
51 52 #endif

3.优化时要用的插入排序：

#ifndef INC_06_QUICK_SORT_DEAL_WITH_NEARLY_ORDERED_ARRAY_INSERTIONSORT_H
#define INC_06_QUICK_SORT_DEAL_WITH_NEARLY_ORDERED_ARRAY_INSERTIONSORT_H
 5  6 template<typename T>
void insertionSort(T arr[],1)"> 8     1 ; i < n ; i ++ ) {
 9         T e =10          j;
11         for (j = i; j > 0 && arr[j-1] > e; j--12             arr[j] = arr[j-13         arr[j] = e;
14 16  对arr[l...r]范围的数组进行插入排序
18 template<typename T>
int i = l+1 ; i <= r ; i ++21         T e =for (j = i; j > l && arr[j-24             arr[j] = arr[j-25         arr[j] =26 27     #endif

4.单路快排实现：

 1 #include <iostream>
 2 #include <algorithm>
 3 #include <ctime>
 4 #include SortTestHelper.hMergeSort.h 6 #include  对arr[l...r]部分进行partition操作
 返回p,使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
10 template <typename T>
11 int _partition(T arr[],1)"> 随机在arr[l...r]的范围中,选择一个数值作为标定点pivot
13     swap( arr[l],arr[rand()%(r-l+1)+l] );
14     T v = arr[l];
int j = l;
int i = l + if( arr[i] < v ){
18             j ++            swap( arr[j],arr[i] );
20 21     swap( arr[l],arr[j]);
22     23 24  对arr[l...r]部分进行快速排序
25 template <typename T>
void _quickSort(T arr[],使用插入排序进行优化
28     30         32     int p = _partition(arr,1)">33     _quickSort(arr,p-34     _quickSort(arr,p+35 36 template <typename T>
void quickSort(T arr[],1)">    srand(time(NULL));
39     _quickSort(arr,1)">);
40  比较Merge Sort和Quick Sort两种排序算法的性能效率
42  main() {
int n = 100000 测试1 一般性测试（随机数） 
45     cout<<Test for random array,size = "<<n<<]46     int* arr1 = SortTestHelper::generateRandomArray(n,1)">047     int* arr2 = SortTestHelper::copyIntArray(arr1,1)">48     SortTestHelper::testSort(Merge Sort49     SortTestHelper::testSort(Quick Sortdelete[] arr1;
51     [] arr2;
52     cout<<53      测试2 测试近乎有序的数组
54      加入了随机选择标定点的步骤后,我们的快速排序可以轻松处理近乎有序的数组
55      但是对于近乎有序的数组,其效率比优化后的归并排序要低,但完全再容忍范围里
int swapTimes = 10057     cout<<Test for nearly ordered array,swap time = "<<swapTimes<<58     arr1 = SortTestHelper::generateNearlyOrderedArray(n,swapTimes);
59     arr2 =60     SortTestHelper::testSort(61     SortTestHelper::testSort(62     63     64     cout<<65      测试3 测试存在包含大量相同元素的数组
66      但此时,对于含有大量相同元素的数组,我们的快速排序算法再次退化成了O(n^2)级别的算法
67     cout<<68     arr1 = SortTestHelper::generateRandomArray(n,1)">1069     arr2 =70     SortTestHelper::testSort(71     SortTestHelper::testSort(72     73     74     return 75 }

图解单路快排：

5.单路快排的测试结果：

可见单路快排在随机测试和近乎有序的情况下效率是完全可以接受的，但是在存在大量重复的元素中表现不是太好，下面我们进行一步一步的优化：
二，双路快排：
只需改一下主函数：

  1 #include <iostream>
  2 #include <algorithm>
  3 #include <ctime>
  4 #include   5 #include   6 #include   7   8   9  10 template <typename T>
 11  12      13     swap( arr[l],1)"> 14     T v = 15      16      17          18             j ++ 19  20  21  22      23  24  双路快速排序的partition
 25  26 template <typename T>
 27 int _partition2(T arr[],1)"> 28      29     swap( arr[l],1)"> 30     T v = 31      arr[l+1...i) <= v; arr(j...r] >= v
 32     1,j = r;
 33     while(  34          注意这里的边界,arr[i] < v,不能是arr[i] <= v
 35         while( i <= r && arr[i] < v )
 36             i ++ 37          38               while( j >= l+1 && arr[j] > 39             j -- 40         if( i > j )
 41             break 42         swap( arr[i],arr[j] );
 43         i ++ 44         j -- 45  46  47      48  49  50 template <typename T>
 51  52      53      54  55          56  57      调用双路快速排序的partition
 58      _partition2(arr,1)"> 59     _quickSort(arr,1)"> 60     _quickSort(arr,1)"> 61  62 template <typename T>
 63  64  65     _quickSort(arr,1)"> 66  67  比较Merge Sort和双路快速排序两种排序算法的性能效率
 68  69      70      测试1 一般性测试
 71     cout<< 72      73      74     SortTestHelper::testSort( 75     SortTestHelper::testSort( 76      77      78     cout<< 79      80      双路快速排序算法也可以轻松处理近乎有序的数组
 81      82     cout<< 83     arr1 = 84     arr2 = 85     SortTestHelper::testSort( 86     SortTestHelper::testSort( 87      88      89     cout<< 90      91      使用双快速排序后,我们的快速排序算法可以轻松的处理包含大量元素的数组
 92     cout<< 93     arr1 = SortTestHelper::generateRandomArray(n,1)"> 94     arr2 = 95     SortTestHelper::testSort( 96     SortTestHelper::testSort( 97      98      99     100 }

图解双路快排：

 

双路快排测试结果：

可见优化后的双路快排在大量重复元素的数组测试中速度提升了近乎200倍，接下来让我们在来看看最棒的三路快排：
三，三路快排：
1.我们将刚才的双路快排写到一个头文件中以便等下测试：

#ifndef INC_07_QUICK_SORT_THREE_WAYS_QUICKSORT_H
#define INC_07_QUICK_SORT_THREE_WAYS_QUICKSORT_H
#include <iostream>
#include <ctime>
#include <algorithm>
#include "InsertionSort.h"
using namespace std;
// 对arr[l...r]部分进行partition操作
// 返回p,使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
template <typename T>
int _partition(T arr[],int l,int r){
// 随机在arr[l...r]的范围中,选择一个数值作为标定点pivot
swap( arr[l],arr[rand()%(r-l+1)+l] );
T v = arr[l];
int j = l;
for( int i = l + 1 ; i <= r ; i ++ )
if( arr[i] < v ){
j ++;
swap( arr[j],arr[i] );
}
swap( arr[l],arr[j]);
return j;
}
// 双路快速排序的partition
// 返回p,使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
template <typename T>
int _partition2(T arr[],arr[rand()%(r-l+1)+l] );
T v = arr[l];
int i = l+1,j = r;
while( true ){
// 注意这里的边界,不能是arr[i] <= v
while( i <= r && arr[i] < v )
i ++;
// 注意这里的边界,不能是arr[j] >= v
while( j >= l+1 && arr[j] > v )
j --;
if( i > j )
break;
swap( arr[i],arr[j] );
i ++;
j --;
}
swap( arr[l],arr[j]);
return j;
}
// 对arr[l...r]部分进行快速排序
template <typename T>
void _quickSort(T arr[],int r){
// 对于小规模数组,使用插入排序进行优化
if( r - l <= 15 ){
insertionSort(arr,r);
return;
}
// 调用双路快速排序的partition
int p = _partition2(arr,r);
_quickSort(arr,p-1 );
_quickSort(arr,p+1,r);
}
template <typename T>
void quickSort(T arr[],int n){
srand(time(NULL));
_quickSort(arr,n-1);
}
#endif

2.三路快排实现：

 7 #include QuickSort.h 递归的三路快速排序算法
void __quickSort3Ways(T arr[],1)">13     15         17     18     swap( arr[l],1)">l ] );
19     T v =int lt = l;      arr[l+1...lt] < v
int gt = r + 1;  arr[gt...r] > v
1;     arr[lt+1...i) == v
23     while( i < gt ){
24         25             swap( arr[i],arr[lt+]);
26             i ++27             lt ++29         if( arr[i] >30             swap( arr[i],arr[gt-31             gt --33         else{  arr[i] == v
34             i ++36 38     __quickSort3Ways(arr,lt-    __quickSort3Ways(arr,gt,1)">41 template <typename T>
void quickSort3Ways(T arr[],1)">43 44     __quickSort3Ways( arr,1)">45 49     cout<<一般随机测试：endl; 
50     cout<<52     int* arr3 =54     SortTestHelper::testSort(55     SortTestHelper::testSort(56     SortTestHelper::testSort(Quick Sort 3 Ways57     59     [] arr3;
60     cout<<61      测试2 测试近乎有序的数组
62     cout<<测试近乎有序的数组64     cout<<65     arr1 =66     arr2 =67     arr3 =68     SortTestHelper::testSort(69     SortTestHelper::testSort(71     74     cout<<75      测试3 测试存在包含大量相同元素的数组
76     cout<<测试存在包含大量相同元素的数组77     cout<<78     arr1 = SortTestHelper::generateRandomArray(n,1)">79     arr2 =80     arr3 =81     SortTestHelper::testSort(82     SortTestHelper::testSort(83     SortTestHelper::testSort(84     85     86     87     88 }

图解三路快排：

 

三路快排运行结果：

可见性能又进一步提升了：
比较Merge Sort和双路快速排序和三路快排三种排序算法的性能效率
对于包含有大量重复数据的数组,三路快排有巨大的优势
对于一般性的随机数组和近乎有序的数组,三路快排的效率虽然不是最优的,但是在可以接受的范围里
因此,在一些语言中,三路快排是默认的语言库函数中使用的排序算法。比如Java:)

 

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

负数原码与补码之间相互转换
背景：计算机内部用补码表示二进制数。符号位1表示负数，0表示正数。正数：无区别，正数 的原码= 反码 = 补码重点讨论负数若已知 负数 -8，则其原码为：1000 1000，（1为符号位，为1代表负数，为0代表正数）反码为：1111 0111，（符号位保持不变，其他位置按位取反）补码为：1111 1000，（反码 + 1）即在计算机中 用 1111 1000表示 -8若已知补码为 1111 1000，如何求其原码呢？（1）方法1：求负数 原码---&gt;补...
MD5 加密算法介绍
大家好,我们现在来讲解关于加密方面的知识,说到加密我认为不得不提MD5,因为这是一种特殊的加密方式,它到底特殊在哪,现在我们就开始学习它全称:message-digest algorithm 5翻译过来就是:信息 摘要 算法 5加密和摘要，是不一样的加密后的消息是完整的；具有解密算法，得到原始数据；摘要得到的消息是不完整的；通过摘要的数据，不能得到原始数据；所以，当看到很多人说，md5，加密，解密的时候，呵呵一笑就好了。MD5长度有人说md5,128位，32位，16位，到
新的快速排序算法: 《Dual-Pivot QuickSort》阅读笔记
相信大家在大学的《算法与数据结构》里面都学过快速排序(QuickSort), 知道这种排序的性能很好，JDK里面直到JDK6用的都是这种经典快排的算法。但是到了JDK7的时候JDK内置的排序算法已经由经典快排变成了Dual-Pivot排序算法。那么Dual-Pivot到底是何方圣神，能比我们学过的经典快排还要快呢？我们一起来看看。经典快排在学习新的快排之前，我们首先来复习一下经典快排，它的核心思想是:接受一个数组，挑一个数(pivot)，然后把比它小的那一摊数放在它的左边，把比它大的那一摊数放
对称加密与非对称加密
加密在编程中的应用的是非常广泛的，尤其是在各种网络协议之中，对称/非对称加密则是经常被提及的两种加密方式。对称加密我们平时碰到的绝大多数加密就是对称加密，比如：指纹解锁，PIN 码锁，保险箱密码锁，账号密码等都是使用了对称加密。对称加密：加密和解密用的是同一个密码或者同一套逻辑的加密方式。这个密码也叫对称秘钥，其实这个对称和不对称指的就是加密和解密用的秘钥是不是同一个。我在上大学的时候做过一个命令行版的图书馆管理系统作为 C 语言课设。登入系统时需要输入账号密码，当然，校验用户输入的密码
详解vue的diff算法
前言我的目标是写一个非常详细的关于diff的干货，所以本文有点长。也会用到大量的图片以及代码举例，目的让看这篇文章的朋友一定弄明白diff的边边角角。先来了解几个点...1. 当数据发生变化时，vue是怎么更新节点的？要知道渲染真实DOM的开销是很大的，比如有时候我们修改了某个数据，如果直接渲染到真实dom上会引起整个dom树的重绘和重排，有没有可能我们只更新我们修改的那一小块dom而不要更新整个dom呢？diff算法能够帮助我们。我们先根据真实DOM生成一颗virtual DOM，当v
对称加密算法
对称加密算法 所有的对称加密都有一个共同的特点：加密和解密所用的密钥是相同的。现代对称密码可以分为序列密码和分组密码两类：序列密码将明文中的每个字符单独加密后再组合成密文；而分组密码将原文分为若干个组，每个组进行整体加密，其最终加密结果依赖于同组的各位字符的具体内容。也就是说，分组加密的结果不仅受密钥影响，也会受到同组其他字符的影响。序列密码分组密码序列密码的安全性看上去要更弱一些，但是由于序列密码只需要对单个位进行操作，因此运行速度比分组加密要快...
RSA密钥长度、明文长度和密文长度
本文介绍RSA加解密中必须考虑到的密钥长度、明文长度和密文长度问题，对第一次接触RSA的开发人员来讲，RSA算是比较复杂的算法，RSA算法自己其实也很简单，RSA的复杂度是由于数学家把效率和安全也考虑进去的缘故。html本文先只谈密钥长度、明文长度和密文长度的概念知识，RSA的理论及示例等之后再谈。提到密钥，咱们不得不提到RSA的三个重要大数：公钥指数e、私钥指数d和模值n。这三个大数是咱们使用RSA时须要直接接触的，理解了本文的基础概念，即便未接触过RSA的开发人员也能应对自如的使用RSA相关函数库，
布隆过滤器(Bloom Filter)详解
直观的说，bloom算法类似一个hash set，用来判断某个元素（key）是否在某个集合中。和一般的hash set不同的是，这个算法无需存储key的值，对于每个key，只需要k个比特位，每个存储一个标志，用来判断key是否在集合中。算法：1. 首先需要k个hash函数，每个函数可以把key散列成为1个整数2. 初始化时，需要一个长度为n比特的数组，每个比特位初始化为03. 某个key加入集合时，用k个hash函数计算出k个散列值，并把数组中对应的比特位置为14. 判断某个key是否在集合时
如何防范密码被破解
你会用什么样的算法来为你的用户保存密码？如果你还在用明码的话，那么一旦你的网站被hack了，那么你所有的用户口令都会被泄露了，这意味着，你的系统或是网站就此完蛋了。所以，我们需要通过一些不可逆的算法来保存用户的密码。比如：MD5, SHA1, SHA256, SHA512, SHA-3,等Hash算法。这些算法都是不可逆的。系统在验证用户的口令时，需要把Hash加密过后的口令与后面存放口令的数据库中的口令做比较，如果一致才算验证通过。但你觉得这些算法好吗？我说的是：MD5, SHA1, SHA256,
Excel表格如何筛选重复内容筛选重复数据的方法
在日常工作中经常会使用excel，有时在表格中需要筛选出重复的数据，该怎么操作呢？1、以下图中的表格数据为例，筛选出列中重复的内容；2、打开文件，选中需要筛选的数据列，依次点击菜单项【开始】-【条件格式】-【突出显示单元格规则】-【重复值】；3、将重复的值突出颜色显示；4、选中数据列，点击【数据】-【筛选】；5、点击列标题的的下拉小三角，点击【按颜色筛选】，即可看到重复的数据；...
第三方接口联调加解密与签名验签
工作中经常有和第三方机构联调接口的事情，顾将用到过的做以记录。 在和第三方联调时，主要步骤为：网络、加解密/签名验签、接口数据等，其中接口数据没啥好说的。 在联调前就需要先将两边的网络连通，一般公司的生产环境都加了防火墙，测试环境有的是有防火墙，有的则没有防火墙，这个需要和第三方人员沟通，如果有防火墙的就需要将我们的出口ip或域名发送给第三方做配置，配置了之后网络一般都是通的。加解密与签名验签： 一般第三方公司都会有加解密或签名验签的，毕竟为了数据安全。一般就是三...
Spring Security安全框架中BCrypt强哈希加密算法使用
此文章不包含认证机制。任何应用考虑到安全，绝不能明文的方式保存密码。密码应该通过某种方式进行加密。如今已有很多标准的算法比如SHA或者MD5再结合salt(盐)使用是一个不错的选择。废话不多说！直接开始SpringBoot 中提供了Spring Security：BCryptPasswordEncoder类,实现Spring的PasswordEncoder接口使用BCrypt强哈希方法来加密密码。第一步：pom导入依赖：&lt;dependency&gt; &lt;groupId...
哈希加密详解和md5、sha1、sha256、Java 工具类
前言在所有的加密算法中使用最多的就是哈希加密了，很多人第一次接触的加密算法如MD5、SHA1都是典型的哈希加密算法，而哈希加密除了用在密码加密上，它还有很多的用途，如提取内容摘要、生成签名、文件对比、区块链等等。这篇文章就是想详细的讲解一下哈希加密，并分享一个哈希加密的工具类。概述哈希函数（Hash Function），也称为散列函数或杂凑函数。哈希函数是一个公开函数，可以将任意长度的消息M映射成为一个长度较短且长度固定的值H（M），称H（M）为哈希值、散列值（Hash Value）、杂凑值或者消息
[排序算法] 快速排序 (C++) (含三种写法)
#快速排序解释 快速排序 Quick Sort 与归并排序一样，也是典型的分治法的应用。 (如果有对 归并排序还不了解的童鞋，可以看看这里哟~ 归并排序)❤❤❤ ###快速排序的分治模式 1、选取基准
[排序算法] 堆排序 (C++)
#堆排序解释 ##什么是堆 堆 heap 是一种近似完全二叉树的数据结构，其满足一下两个性质 1. 堆中某个结点的值总是不大于(或不小于)其父结点的值； 2. 堆总是一棵完全二叉树 将根结点最大的堆叫
[排序算法] 希尔排序 (C++)
#前言 本文章是建立在插入排序的基础上写的喔，如果有对插入排序还有不懂的童鞋，可以看看这里。 ❤❤❤ 直接/折半插入排序 2路插入排序 ❤❤❤ #希尔排序解释 希尔排序 Shell Sort 又名&q
[排序算法] 归并排序 (C++)
#归并排序解释 归并排序 Merge Sort 是典型的分治法的应用，其算法步骤完全遵循分治模式。 ##分治法思想 分治法 思想: 将原问题分解为几个规模较小但又保持原问题性质的子问题，递归求解这些子
[排序算法] 双向冒泡排序 (C++)
#前言 本文章是建立在冒泡排序的基础上写的，如还有对 冒泡排序 不了解的童鞋，可以看看这里哦~ 冒泡排序 C++ #双向冒泡排序原理 双向冒泡排序 的基本思想与 冒泡排序还是一样的。冒泡排序 每次将相
[排序算法] 直接/折半插入排序 (C++)
#插入排序解释 插入排序很好理解，其步骤是 ：先将第一个数据元素看作是一个有序序列，后面的 n-1 个数据元素看作是未排序序列。对后面未排序序列中的第一个数据元素在这个有序序列中进行从后往前扫描，找到
[排序算法] 桶排序 (C++)
#桶排序解释 ##桶排序思想 桶排序 是一种空间换取时间的排序方式，是非基于比较的。 桶排序 顾名思义，就是构建多个映射数据的桶，将数据放入桶内，对每个桶内元素进行单独排序。假设我们有 n 个待排序的
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot