以力扣912.排序数组为例，比较不同排序的实现效果
给你一个整数数组 nums，请你将该数组升序排列。
排序模板：
示例一：
输入：nums = [5,2,3,1]
输出：[1,2,3,5]
示例二：
输入：nums = [5,1,1,2,0,0]
输出：[0,0,1,1,2,5]
提示：
1 <= nums.length <= 50000
-50000 <= nums[i] <= 50000
解法一：API接口直接排
C++
class Solution {
public:
vector<int> sortArray(vector<int>& nums) {
sort(nums.begin(),nums.end());
return nums;
}
};
JAVA
class Solution {
public int[] sortArray(int[] nums) {
Arrays.sort(nums);
return nums;
}
}
解法二：选择排序
C++
class Solution {
public:
void choosesort(vector<int>&nums){
for(int i=0;i<nums.size();i++){
for(int j=i+1;j<nums.size();j++)//选出较小元素，逐次交换过去
if(nums[j]<nums[i])swap(nums[j],nums[i]);
}
}
vector<int> sortArray(vector<int>& nums) {
choosesort(nums);
return nums;
}
};
JAVA
class Solution {
public static void selectionSort(int[] arr) {
int minIndex;
for (int i = 0; i < arr.length - 1; i++) {
minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[minIndex] > arr[j]) {
// 记录最小值的下标
minIndex = j;
}
}
// 将最小元素交换至首位
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
public int[] sortArray(int[] nums) {
selectionSort(nums);
return nums;
}
}
解法三:冒泡排序
C++
class Solution {
public:
void bubblesort(vector<int>&nums){
for(int i=0;i<nums.size()-1;i++){
for(int j=0;j<nums.size()-i-1;j++){
if(nums[j]>nums[j+1])swap(nums[j],nums[j+1]);
}//在一轮中，最大的元素冒泡般地从左移到右
}
}
vector<int> sortArray(vector<int>& nums) {
bubblesort(nums);
return nums;
}
};
JAVA
class Solution {
public static void bubbleSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
// 如果左边的数大于右边的数，则交换，保证右边的数字最大
swap(arr, j, j + 1);
}
}
}
}
// 交换元素
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public int[] sortArray(int[] nums) {
bubbleSort(nums);
return nums;
}
}
解法四：插入排序
C++
class Solution {
public:
void insertsort(vector<int>&nums){
for(int i=1;i<nums.size();i++){
int tmp=nums[i];
int j;
for(j=i-1;j>=0;j--){
if(nums[j]>tmp)nums[j+1]=nums[j];//插牌一般，选择位置插入
else break;
}
nums[j+1]=tmp;
}
}
vector<int> sortArray(vector<int>& nums) {
insertsort(nums);
return nums;
}
};
JAVA
class Solution {
public static void insertSort(int[] arr) {
// 从第二个数开始，往前插入数字
for (int i = 1; i < arr.length; i++) {
// j 记录当前数字下标
int j = i;
// 当前数字比前一个数字小，则将当前数字与前一个数字交换
while (j >= 1 && arr[j] < arr[j - 1]) {
swap(arr, j, j - 1);
// 更新当前数字下标
j--;
}
}
}
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public int[] sortArray(int[] nums) {
insertSort(nums);
return nums;
}
}
解法五：快速排序
C++
class Solution {
public:
void qssort(vector<int>&nums,int l,int r){
int i=l,j=r,flag=nums[l+(r-l)/2];//先选出标杆flag
do{
while(nums[i]<flag)i++;//从左找比标杆大的数
while(nums[j]>flag)j--;//从右找比标杆小的数
if(i<=j){//位置不匹配的元素，交换
swap(nums[i],nums[j]);
i++;
j--;
}
}while(i<=j);
if(l<j)qssort(nums,l,j);
if(i<r)qssort(nums,i,r);
}
vector<int> sortArray(vector<int>& nums) {
int n=nums.size();
qssort(nums,0,n-1);
return nums;
}
};
快排还是很强的
JAVA
class Solution {//这里用了一种随机化的快排方式
public void swap(int[] nums, int i, int j){
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
// 把数组分为两半，返回分割中点
public int change(int[] nums, int low, int high){
// 随机化
Random rm = new Random();
// [0, high]
int index = rm.nextInt(high-low+1) + low;
swap(nums, index, low);
// low变成一个洞
int pivot = nums[low];
while(low < high){
while(low < high && nums[high] > pivot) high--;
nums[low] = nums[high];
while(low < high && nums[low] <= pivot) low++;
nums[high] = nums[low];
}
nums[low] = pivot;
return low;
}
// 快速排序
public void quickSort(int[] nums, int low, int high){
if(low >= high) return;
// 左右两边有序
int mid = change(nums, low, high);
quickSort(nums, low, mid-1);
quickSort(nums, mid+1, high);
}
public int[] sortArray(int[] nums) {
quickSort(nums,0,nums.length-1);
return nums;
}
}
解法六：希尔排序
C++
class Solution {
public:
void shellsort(vector<int>& nums) {
int n=nums.size();
for(int inc=n/2;inc>=1;inc/=2){//增量inc从n/2开始每次减半，直到1
for(int k=0;k<=inc-1;k++){//对于每个inc，相同inc间隔的元素当做一个数组
for(int j=k+inc;j<n;j+=inc){//k是每个数组的第一个元素下标0,1，inc-1，对每个数组进行插入排序
int i=j-inc;//j是需要处理的元素，i=j-inc是已经处理好的数组的末尾
tmp=nums[j] //从i开始逆向遍历
int tmp=nums[j];
while(i>=k&&nums[i]>tmp){//while nums[i]>tmp,nums[i]放在tmp后面，即nums[i+inc]=nums[i]
nums[i+inc]=nums[i];
i-=inc;//否则nums[i]应该在tmp前面，nums[i+inc]=tmp；
}
nums[i+inc]=tmp;
}
}
}
}
vector<int> sortArray(vector<int>& nums) {
int n=nums.size();
shellsort(nums);
return nums;
}
};
JAVA
class Solution {
public static void shellSortByKnuth(int[] arr) {
// 找到当前数组需要用到的 Knuth 序列中的最大值
int maxKnuthNumber = 1;
while (maxKnuthNumber <= arr.length / 3) {
maxKnuthNumber = maxKnuthNumber * 3 + 1;
}
// 增量按照 Knuth 序列规则依次递减
for (int gap = maxKnuthNumber; gap > 0; gap = (gap - 1) / 3) {
// 从 gap 开始，按照顺序将每个元素依次向前插入自己所在的组
for (int i = gap; i < arr.length; i++) {
// currentNumber 站起来，开始找位置
int currentNumber = arr[i];
// 该组前一个数字的索引
int preIndex = i - gap;
while (preIndex >= 0 && currentNumber < arr[preIndex]) {
// 向后挪位置
arr[preIndex + gap] = arr[preIndex];
preIndex -= gap;
}
// currentNumber 找到了自己的位置，坐下
arr[preIndex + gap] = currentNumber;
}
}
}
public int[] sortArray(int[] nums) {
shellSortByKnuth(nums);
return nums;
}
}
解法七：归并排序
C++
class Solution {//归并字好多，处理好合并问题即可，归并排序是分治思想的典型
public:
void mergesort(vector<int>&nums,int beg,int end){
if(beg>=end)return;
int mid=beg+(end-beg)/2;//防溢出
mergesort(nums,beg,mid);
mergesort(nums,mid+1,end);
vector<int>nums2(nums.begin()+mid+1,nums.begin()+end+1);
merge(nums,beg,mid,end,nums2,end-mid);
}
void merge(vector<int>&nums1,int beg,int mid,int end,vector<int>&nums2,int n){
int right=end+1,cur1=mid,cur2=n-1;//合并两数组
while(true){
if(cur1==beg-1&&cur2==-1)return ;
else if(cur1==beg-1&&cur2!=-1){
right--;
nums1[right]=nums2[cur2];
cur2--;
}
else if(cur1!=beg-1&&cur2==-1)return ;
else if(nums1[cur1]>=nums2[cur2]){
right--;
nums1[right]=nums1[cur1];
cur1--;
}
else if(nums1[cur1]<nums2[cur2]){
right--;
nums1[right]=nums2[cur2];
cur2--;
}
}
}
vector<int> sortArray(vector<int>& nums) {
int n=nums.size();
mergesort(nums,0,n-1);
return nums;
}
};
JAVA
class Solution {
public static void mergeSort(int[] arr) {
if (arr.length == 0) return;
mergeSort(arr, 0, arr.length - 1);
}
// 对 arr 的 [start, end] 区间归并排序
private static void mergeSort(int[] arr, int start, int end) {
// 只剩下一个数字，停止拆分
if (start == end) return;
int middle = (start + end) / 2;
// 拆分左边区域
mergeSort(arr, start, middle);
// 拆分右边区域
mergeSort(arr, middle + 1, end);
// 合并左右区域
merge(arr, start, end);
}
// 将 arr 的 [start, middle] 和 [middle + 1, end] 区间合并
private static void merge(int[] arr, int start, int end) {
int end1 = (start + end) / 2;
int start2 = end1 + 1;
// 用来遍历数组的指针
int index1 = start;
while (index1 <= end1 && start2 <= end) {
if (arr[index1] > arr[start2]) {
// 将 index1 和 start2 下标的数字交换
exchange(arr, index1, start2);
if (start2 != end) {
// 调整交换到 start2 上的这个数字的位置，使右边区域继续保持有序
int value = arr[start2];
int index = start2;
// 右边区域比 arr[start2] 小的数字不断前移
while (index < end && arr[index + 1] < value) {
arr[index] = arr[index + 1];
index++;
}
// 交换到右边区域的这个数字找到了自己合适的位置，坐下
arr[index] = value;
}
}
index1++;
}
}
private static void exchange(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public int[] sortArray(int[] nums) {
mergeSort(nums,0,nums.length-1);
return nums;
}
}
解法八：堆排序
补充：数据结构之——
堆：符合以下两个条件之一的完全二叉树：
根节点的值 ≥ 子节点的值，这样的堆被称之为最大堆，或大顶堆；
根节点的值 ≤ 子节点的值，这样的堆被称之为最小堆，或小顶堆。
C++
class Solution {//堆排序，还没学堆结构的同学，可以先了解一下
public:
void heapify(vector<int>&nums,int cur,int n){
int left=cur*2+1,right=cur*2+2;
while(left<n){
int largestIndex=(nums[cur]>=nums[left])?cur:left;
if(right<n&&nums[right]>nums[largestIndex])largestIndex=right;
if(largestIndex==cur)break;
swap(nums[cur],nums[largestIndex]);
cur=largestIndex;
left=cur*2+1,right=cur*2+2;
}
}
void heapsort(vector<int>&nums){
int n=nums.size();
for(int i=0;i<n;i++){
int cur=i;
int fa=(cur-1)/2;
while(nums[cur]>nums[fa]){
swap(nums[cur],nums[fa]);
cur=fa;
fa=(cur-1)/2;
}
}
for(int j=n;j>=1;j--){
swap(nums[0],nums[j-1]);
heapify(nums,0,j-1);
}
}
vector<int> sortArray(vector<int>& nums) {
int n=nums.size();
heapsort(nums);
return nums;
}
};
JAVA
class Solution {
public static void heapSort(int[] arr) {
// 构建初始大顶堆
buildMaxHeap(arr);
for (int i = arr.length - 1; i > 0; i--) {
// 将最大值交换到数组最后
swap(arr, 0, i);
// 调整剩余数组，使其满足大顶堆
maxHeapify(arr, 0, i);
}
}
// 构建初始大顶堆
private static void buildMaxHeap(int[] arr) {
// 从最后一个非叶子结点开始调整大顶堆，最后一个非叶子结点的下标就是 arr.length / 2-1
for (int i = arr.length / 2 - 1; i >= 0; i--) {
maxHeapify(arr, i, arr.length);
}
}
// 调整大顶堆，第三个参数表示剩余未排序的数字的数量，也就是剩余堆的大小
private static void maxHeapify(int[] arr, int i, int heapSize) {
// 左子结点下标
int l = 2 * i + 1;
// 右子结点下标
int r = l + 1;
// 记录根结点、左子树结点、右子树结点三者中的最大值下标
int largest = i;
// 与左子树结点比较
if (l < heapSize && arr[l] > arr[largest]) {
largest = l;
}
// 与右子树结点比较
if (r < heapSize && arr[r] > arr[largest]) {
largest = r;
}
if (largest != i) {
// 将最大值交换为根结点
swap(arr, i, largest);
// 再次调整交换数字后的大顶堆
maxHeapify(arr, largest, heapSize);
}
}
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public int[] sortArray(int[] nums) {
heapSort(nums);
return nums;
}
}
解法九：计数排序
C++
class Solution {//把计数数组作为临时的储存器
public:
void countsort(vector<int>&nums){
int n=nums.size();
int minNum=nums[0],maxNum=nums[0];
for(int num:nums){
minNum=min(minNum,num);
maxNum=max(maxNum,num);//其实可以一次性开个INT_MAX的
} //但这消耗太大
vector<int>cnt(maxNum-minNum+1,0);//创建计数数组
for(int num:nums)cnt[num-minNum]++;
int j=0;
for(int i=0;i<maxNum-minNum+1;i++){//把储存的元素从小到大倒出来
while(cnt[i]>0){
nums[j++]=i+minNum;
cnt[i]--;
}
}
}
vector<int> sortArray(vector<int>& nums) {
int n=nums.size();
countsort(nums);
return nums;
}
};
JAVA
class Solution {
public static void countingSort(int[] arr) {
// 判空及防止数组越界
if (arr == null || arr.length <= 1) return;
// 找到最大值，最小值
int max = arr[0];
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) max = arr[i];
else if (arr[i] < min) min = arr[i];
}
// 确定计数范围
int range = max - min + 1;
// 建立长度为 range 的数组，下标 0~range-1 对应数字 min~max
int[] counting = new int[range];
// 遍历 arr 中的每个元素
for (int element : arr) {
// 将每个整数出现的次数统计到计数数组中对应下标的位置，这里需要将每个元素减去 min，才能映射到 0～range-1 范围内
counting[element - min]++;
}
// 记录前面比自己小的数字的总数
int preCounts = 0;
for (int i = 0; i < range; i++) {
// 当前的数字比下一个数字小，累计到 preCounts 中
preCounts += counting[i];
// 将 counting 计算成当前数字在结果中的起始下标位置。位置 = 前面比自己小的数字的总数。
counting[i] = preCounts - counting[i];
}
int[] result = new int[arr.length];
for (int element : arr) {
// counting[element - min] 表示此元素在结果数组中的下标
result[counting[element - min]] = element;
// 更新 counting[element - min]，指向此元素的下一个下标
counting[element - min]++;
}
// 将结果赋值回 arr
for (int i = 0; i < arr.length; i++) {
arr[i] = result[i];
}
}
public int[] sortArray(int[] nums) {
countingSort(nums);
return nums;
}
}
解法十：基数排序
（注意这里是有负数的，无负数的话，基数选0，1，2，3，4，5，6，7，8，9，十个即可）
C++
class Solution {
public:
void radixsort(vector<int>&nums){
int n=nums.size();
if(n==0)return;
int maxNum=0;
for(int val:nums){//有负数的话，不能直接max_element挑元素
if(abs(val)>maxNum)maxNum=abs(val);
}
int maxBit=0;
while(maxNum){
maxBit++;
maxNum/=10;
} //计算最高数位
vector<int>buf(n); //也是桶排序的一种特例
int dev=1;
for(int i=0;i<maxBit;i++){
vector<int>cnt(19,0);//每次循环，重置数组
for(int val:nums){
int redix=val/dev%10+9;
cnt[redix]++;
}
for(int j=1;j<cnt.size();j++){
cnt[j]+=cnt[j-1];
}
for(int j=nums.size()-1;j>=0;j--){
int redix=nums[j]/dev%10+9;
buf[--cnt[redix]]=nums[j];
}
copy(buf.begin(),buf.end(),nums.begin()); // 计数排序完成后，将结果拷贝回 nums 数组
dev*=10;
}
}
vector<int> sortArray(vector<int>& nums) {
radixsort(nums);
return nums;
}
};
JAVA
class Solution {
public static void radixSort(int[] arr) {
if (arr == null) return;
// 找出最长的数
int max = 0;
for (int value : arr) {
if (Math.abs(value) > max) {
max = Math.abs(value);
}
}
// 计算最长数字的长度
int maxDigitLength = 0;
while (max != 0) {
maxDigitLength++;
max /= 10;
}
// 使用计数排序算法对基数进行排序，下标 [0, 18] 对应基数 [-9, 9]
int[] counting = new int[19];
int[] result = new int[arr.length];
int dev = 1;
for (int i = 0; i < maxDigitLength; i++) {
for (int value : arr) {
// 下标调整
int radix = value / dev % 10 + 9;
counting[radix]++;
}
for (int j = 1; j < counting.length; j++) {
counting[j] += counting[j - 1];
}
// 使用倒序遍历的方式完成计数排序
for (int j = arr.length - 1; j >= 0; j--) {
// 下标调整
int radix = arr[j] / dev % 10 + 9;
result[--counting[radix]] = arr[j];
}
// 计数排序完成后，将结果拷贝回 arr 数组
System.arraycopy(result, 0, arr, 0, arr.length);
// 将计数数组重置为 0
Arrays.fill(counting, 0);
dev *= 10;
}
}
public int[] sortArray(int[] nums) {
radixSort(nums);
return nums;
}
}
解法十一：桶排序
C++
class Solution {
public:
void bucketsort(vector<int>& nums) {
int n=nums.size();
int maxNum=*max_element(nums.begin(),nums.end());
int minNum=*min_element(nums.begin(),nums.end());
int bucketCnt=(maxNum-minNum)/n+1;//创建桶
vector<vector<int>>buckets(bucketCnt);
for(auto &num:nums){//把nums里的元素倒进桶里面
int bucketIdx=(num-minNum)/bucketCnt;
if(bucketIdx>=bucketCnt)bucketIdx=bucketCnt-1;
buckets[bucketIdx].emplace_back(num);
}
nums.clear();
for(auto&bucket:buckets){//对每个桶里的元素进行排序，再倒出来
sort(bucket.begin(),bucket.end());
for(int &num:bucket)nums.emplace_back(num);
}
}
vector<int> sortArray(vector<int>& nums) {
bucketsort(nums);
return nums;
}
};
JAVA
class Solution {
public static void bucketSort(int[] arr) {
// 判空及防止数组越界
if (arr == null || arr.length <= 1) return;
// 找到最大值，最小值
int max = arr[0];
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) max = arr[i];
else if (arr[i] < min) min = arr[i];
}
// 确定取值范围
int range = max - min;
// 设置桶的数量，这里我们设置为 100 个，可以根据实际情况修改。
int bucketAmount = 100;
// 桶和桶之间的间距
double gap = range * 1.0 / (bucketAmount - 1);
// 用二维数组来装桶，第一个维度是桶的编号，第二个维度是桶中的数字。初始化长度为 0
int[][] buckets = new int[bucketAmount][];
// 装桶
for (int value : arr) {
// 找到 value 属于哪个桶
int index = (int) ((value - min) / gap);
buckets[index] = add(buckets[index], value);
}
int index = 0;
// 对每个桶内的数字进行单独排序
for (int i = 0; i < bucketAmount; i++) {
if (buckets[i] == null || buckets[i].length == 0) continue;
// 这里需要结合其他排序算法，例如：插入排序
insertSort(buckets[i]);
// 排序完成后将桶内的结果收集起来
System.arraycopy(buckets[i], 0, arr, index, buckets[i].length);
index += buckets[i].length;
}
}
// 数组扩容
public static int[] add(int[] arr, int num) {
if (arr == null) return new int[]{num};
int[] newArr = Arrays.copyOf(arr, arr.length + 1);
newArr[arr.length] = num;
return newArr;
}
// 插入排序
public static void insertSort(int[] arr) {
// 从第二个数开始，往前插入数字
for (int i = 1; i < arr.length; i++) {
int currentNumber = arr[i];
int j = i - 1;
// 寻找插入位置的过程中，不断地将比 currentNumber 大的数字向后挪
while (j >= 0 && currentNumber < arr[j]) {
arr[j + 1] = arr[j];
j--;
}
// 两种情况会跳出循环：1. 遇到一个小于或等于 currentNumber 的数字，跳出循环，currentNumber 就坐到它后面。
// 2. 已经走到数列头部，仍然没有遇到小于或等于 currentNumber 的数字，也会跳出循环，此时 j 等于 -1，currentNumber 就坐到数列头部。
arr[j + 1] = currentNumber;
}
}
public int[] sortArray(int[] nums) {
bucketSort(nums);
return nums;
}
}
解法：十二到正无穷：双插入排序、双轴快排、拓扑排序（咳咳，拓扑排序是用来凑数的）…
我先休息一下<(＿ ＿)>
动图展示及主要思想
选择排序-2：
（✔使用英雄前辈的图）英雄前辈的讲解
选排思想：双重循环遍历数组，每经过一轮比较，找到最小元素的下标，将其交换至首位。
冒泡排序-3
冒泡思想：一边比较一边向后两两交换，将最大值 / 最小值冒泡到最后一位；
插入排序-4
插排思想：非常简单，生活中有一个很常见的场景：在打扑克牌时，我们一边抓牌一边给扑克牌排序，每次摸一张牌，就将它插入手上已有的牌中合适的位置，逐渐完成整个排序。
快速排序-5
快排思想：1、从数组中取出一个数，称之为基数（pivot）
2.遍历数组，将比基数大的数字放到它的右边，比基数小的数字放到它的左边。
3.遍历完成后，数组被分成了左右两个区域
将左右两个区域视为两个数组，重复前两个步骤，直到排序完成
希尔排序-6：
希尔排序思想：
1、将待排序数组按照一定的间隔分为多个子数组，每组分别进行插入排序。这里按照间隔分组指的不是取连续的一段数组，而是每跳跃一定间隔取一个值组成一组
2、逐渐缩小间隔进行下一轮排序
3、最后一轮时，取间隔为 11，也就相当于直接使用插入排序。但这时经过前面的「宏观调控」，数组已经基本有序了，所以此时的插入排序只需进行少量交换便可完成
归并排序-7
归并排序思想：总结起来，归并排序分成两步，一是拆分数组，二是合并数组，它是分治思想的典型应用。分治的意思是“分而治之”，分的时候体现了二分的思想。
堆排序-8：
堆排思想：1、用数列构建出一个大顶堆；
2、取出堆顶的数字后，如何将剩余的数字调整成新的大顶堆。
计数排序-9：
（英雄前辈的图）算法零基础讲解
计数排序思想：1、首先我们将每位元素出现的次数记录到 counting 数组中。
2、然后将 counting[i] 更新为数字 i 在最终排序结果中的起始下标位置。这个位置等于前面比自己小的数字的总数。
基数排序-10：
基排思想：这种利用多关键字进行排序，这里的关键字指的是数字的某位上的数
桶排序-11：
桶排序思想：
1、将区间划分为 n 个相同大小的子区间，每个子区间称为一个桶
2、遍历数组，将每个数字装入桶中
3、对每个桶内的数字单独排序，这里需要采用其他排序算法，如插入、归并、快排等
4.最后按照顺序将所有桶内的数字合并起来
总结：
尽管我们已经有很快的API接口，但这些排序算法依然是我们算法学习的必经之路。学好它们，深刻理解它们所包含的算法思想，对算法学习大有帮助。🐱🏍
注：参考：《算法导论》《算法第四版》《算法零基础入门》《力扣leetbook》。
动图引自《算法零基础入门》《力扣leetbook》，加网上搜图。
时间复杂度：
O(n),冒泡排序，选择排序，插入排序
O(nlogn),希尔排序，堆排序，快速排序，归并排序，API接口
O(n),计数排序，基数排序，桶排序。前两者是桶排序的特殊实现。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
