精华内容
下载资源
问答
  • #include<iostream> using namespace std;...//待排序的数组。 int n;//成员数组a实际元素个数 public: KB(int t[],int n1)//构造函数,初始化数据成员。 { n=n1; for(int i=0;i<n;i++) a[...
    #include<iostream>
    using namespace std;
    class KB
    {
    	private:
    		int a[5] ;//待排序的数组。
    		int n;//成员数组a实际元素个数
    	public:
    	KB(int t[],int n1)//构造函数,初始化数据成员。
    		{
    			n=n1;
    			for(int i=0;i<n;i++)
    			a[i]=t[i];
    		}
    	int num(int n)//返回去掉参数n最高位后得到的数值。
    		{
    		int i=0,m=0;
    	    int a[10],b[10];
    	       while(n)
    	    {
    		a[i++]=n%10;
    		n=n/10;
    	    }//结束循环后a[i]数组从尾到头储存n这个数 
    	   for(int j=i-2;j>=0;j--)//j=i-2使得跳过了n这个数的第一位 
        	b[m++]=a[j]; 
        	int t=0;
        	for(int x=0;x<i-1;x++)
        	t=t*10+b[x];
            return t;
    		}
    	void fun()//选择排序 
    	{
    		for(int i=0;i<n-1;i++)
    		for(int j=i+1;j<n;j++)
    		if(num(a[i])>num(a[j]))
    		{
    			int temp;
    			temp=a[i];
    			a[i]=a[j];
    			a[j]=temp;
    		}
    		
    	}
    	void print()
    	{
    		for(int i=0;i<n;i++)
    		cout<<a[i]<<'\t';
    	}
    };
    int main()
    {
    	int tt[5]={134,445,423,233,811};
    	KB zk(tt,5);
    	zk.print() ;
    	cout<<endl;
    	zk.fun() ;
    	zk.print() ;
    }
    
    

    标题

    展开全文
  • 3.如果该元素大于tem,则将该元素移到下一位 4.重复步骤3,直到找到已排序元素中小于等于tem的元素 5.tem插入到该元素的后面,如果已排序所有元素都大于tem,则将tem插入到下标为0的位置 6.重复步骤2~5 动图演示如下...


    1. 插入排序

    步骤:

    1.从第一个元素开始,该元素可以认为已经被排序
    2.取下一个元素tem,从已排序的元素序列从后往前扫描
    3.如果该元素大于tem,则将该元素移到下一位
    4.重复步骤3,直到找到已排序元素中小于等于tem的元素
    5.tem插入到该元素的后面,如果已排序所有元素都大于tem,则将tem插入到下标为0的位置
    6.重复步骤2~5

    动图演示如下:在这里插入图片描述
    思路:
      在待排序的元素中,假设前n-1个元素已有序,现将第n个元素插入到前面已经排好的序列中,使得前n个元素有序。按照此法对所有元素进行插入,直到整个序列有序。
      但我们并不能确定待排元素中究竟哪一部分是有序的,所以我们一开始只能认为第一个元素是有序的,依次将其后面的元素插入到这个有序序列中来,直到整个序列有序为止。
    在这里插入图片描述
    代码如下:

    void InsertSort(int* arr, int n)
    {
    	for (int i = 0; i < n - 1; ++i)
    	{
    		//记录有序序列最后一个元素的下标
    		int end = i;
    		//待插入的元素
    		int tem = arr[end + 1];
    		//单趟排
    		while (end >= 0)
    		{
    			//比插入的数大就向后移
    			if (tem < arr[end])
    			{
    				arr[end + 1] = arr[end];
    				end--;
    			}
    			//比插入的数小,跳出循环
    			else
    			{
    				break;
    			}
    		}
    		//tem放到比插入的数小的数的后面
    		arr[end  + 1] = tem;
    		//代码执行到此位置有两种情况:
    		//1.待插入元素找到应插入位置(break跳出循环到此)
    		//2.待插入元素比当前有序序列中的所有元素都小(while循环结束后到此)
    	}
    }
    

    时间复杂度:最坏情况下为O(N*N),此时待排序列为逆序,或者说接近逆序
          最好情况下为O(N),此时待排序列为升序,或者说接近升序。
    空间复杂度:O(1)

    2.希尔排序

    步骤:
    1.先选定一个小于N的整数gap作为第一增量,然后将所有距离为gap的元素分在同一组,并对每一组的元素进行直接插入排序。然后再取一个比第一增量小的整数作为第二增量,重复上述操作…
    2.当增量的大小减到1时,就相当于整个序列被分到一组,进行一次直接插入排序,排序完成。
    动图如下:
    在这里插入图片描述
    思路:
    希尔排序,先将待排序列进行预排序,使待排序列接近有序,然后再对该序列进行一次插入排序,此时插入排序的时间复杂度为O(N),

    代码如下:

    //希尔排序
    void ShellSort(int* arr, int n)
    {
    	int gap = n;
    	while (gap>1)
    	{
    		//每次对gap折半操作
    		gap = gap / 2;
    		//单趟排序
    		for (int i = 0; i < n - gap; ++i)
    		{
    			int end = i;
    			int tem = arr[end + gap];
    			while (end >= 0)
    			{
    				if (tem < arr[end])
    				{
    					arr[end + gap] = arr[end];
    					end -= gap;
    				}
    				else
    				{
    					break;
    				}
    			}
    			arr[end + gap] = tem;
    		}
    	}
    }
    

    时间复杂度平均:O(N^1.3)
    空间复杂度:O(1)

    3.选择排序

    思路:
    每次从待排序列中选出一个最小值,然后放在序列的起始位置,直到全部待排数据排完即可。
    实际上,我们可以一趟选出两个值,一个最大值一个最小值,然后将其放在序列开头和末尾,这样可以使选择排序的效率快一倍。

    动图如下:
    在这里插入图片描述
    代码如下:

    //选择排序
    void swap(int* a, int* b)
    {
    	int tem = *a;
    	*a = *b;
    	*b = tem;
    }
    void SelectSort(int* arr, int n)
    {
    	//保存参与单趟排序的第一个数和最后一个数的下标
    	int begin = 0, end = n - 1;
    	while (begin < end)
    	{
    		//保存最大值的下标
    		int maxi = begin;
    		//保存最小值的下标
    		int mini = begin;
    		//找出最大值和最小值的下标
    		for (int i = begin; i <= end; ++i)
    		{
    			if (arr[i] < arr[mini])
    			{
    				mini = i;
    			}
    			if (arr[i] > arr[maxi])
    			{
    				maxi = i;
    			}
    		}
    		//最小值放在序列开头
    		swap(&arr[mini], &arr[begin]);
    		//防止最大的数在begin位置被换走
    		if (begin == maxi)
    		{
    			maxi = mini;
    		}
    		//最大值放在序列结尾
    		swap(&arr[maxi], &arr[end]);
    		++begin;
    		--end;
    	}
    }
    

    时间复杂度:最坏情况:O(N^2)
          最好情况:O(N^2)
    空间复杂度:O(1)

    4.冒泡排序

    思路:
    左边大于右边交换一趟排下来最大的在右边

    动图如下:
    在这里插入图片描述
    代码如下:

    //冒泡排序
    void BubbleSort(int* arr, int n)
    {
    	int end = n;
    	while (end)
    	{
    		int flag = 0;
    		for (int i = 1; i < end; ++i)
    		{
    			if (arr[i - 1] > arr[i])
    			{
    				int tem = arr[i];
    				arr[i] = arr[i - 1];
    				arr[i - 1] = tem;
    				flag = 1;
    			}
    		}
    		if (flag == 0)
    		{
    			break;
    		}
    		--end;
    	}
    }
    

    时间复杂度:最坏情况:O(N^2)
          最好情况:O(N)
    空间复杂度:O(1)

    5.堆排序

    堆排可看之间这篇博文----->[堆排]

    6.快速排序

    5.1 hoare版本(左右指针法)

    思路:
    1、选出一个key,一般是最左边或是最右边的。
    2、定义一个begin和一个end,begin从左向右走,end从右向左走。(需要注意的是:若选择最左边的数据作为key,则需要end先走;若选择最右边的数据作为key,则需要bengin先走)。
    3、在走的过程中,若end遇到小于key的数,则停下,begin开始走,直到begin遇到一个大于key的数时,将begin和right的内容交换,end再次开始走,如此进行下去,直到begin和end最终相遇,此时将相遇点的内容与key交换即可。(选取最左边的值作为key)
    4.此时key的左边都是小于key的数,key的右边都是大于key的数
    5.将key的左序列和右序列再次进行这种单趟排序,如此反复操作下去,直到左右序列只有一个数据,或是左右序列不存在时,便停止操作,此时此部分已有序

    单趟动图如下:
    在这里插入图片描述
    代码如下:

    //快速排序   hoare版本(左右指针法)
    void QuickSort(int* arr, int begin, int end)
    {
    	//只有一个数或区间不存在
    	if (begin >= end)
    		return;
    	int left = begin;
    	int right = end;
    	//选左边为key
    	int keyi = begin;
    	while (begin < end)
    	{
    		//右边选小   等号防止和key值相等    防止顺序begin和end越界
    		while (arr[end] >= arr[keyi] && begin < end)
    		{
    			--end;
    		}
    		//左边选大
    		while (arr[begin] <= arr[keyi] && begin < end)
    		{
    			++begin;
    		}
    		//小的换到右边,大的换到左边
    		swap(&arr[begin], &arr[end]);
    	}
    	swap(&arr[keyi], &arr[end]);
    	keyi = end;
    	//[left,keyi-1]keyi[keyi+1,right]
    	QuickSort(arr, left, keyi - 1);
    	QuickSort(arr,keyi + 1,right);
    }
    

    时间复杂度:
    在这里插入图片描述
    快速排序的过程类似于二叉树其高度为logN,每层约有N个数,如下图所示:在这里插入图片描述

    5.2 挖坑法

    思路:
    挖坑法思路与hoare版本(左右指针法)思路类似
    1.选出一个数据(一般是最左边或是最右边的)存放在key变量中,在该数据位置形成一个坑
    2、还是定义一个L和一个R,L从左向右走,R从右向左走。(若在最左边挖坑,则需要R先走;若在最右边挖坑,则需要L先走)

    后面的思路与hoare版本(左右指针法)思路类似在此处就不说了

    单趟动图如下:
    在这里插入图片描述
    代码如下:

    //快速排序法  挖坑法
    void QuickSort1(int* arr, int begin, int end)
    {
    	if (begin >= end)
    		return;
    	int left = begin,right = end;
    	int key = arr[begin];
    	while (begin < end)
    	{
    		//找小
    		while (arr[end] >= key && begin < end)
    		{
    			--end;
    		}
    		//小的放到左边的坑里
    		arr[begin] = arr[end];
    		//找大
    		while (arr[begin] <= key && begin < end)
    		{
    			++begin;
    		}
    		//大的放到右边的坑里
    		arr[end] = arr[begin];
    	}
    	arr[begin] = key;
    	int keyi = begin;
    	//[left,keyi-1]keyi[keyi+1,right]
    	QuickSort1(arr, left, keyi - 1);
    	QuickSort1(arr, keyi + 1, right);
    }
    

    5.3 前后指针法

    思路:
    1、选出一个key,一般是最左边或是最右边的。
    2、起始时,prev指针指向序列开头,cur指针指向prev+1。
    3、若cur指向的内容小于key,则prev先向后移动一位,然后交换prev和cur指针指向的内容,然后cur指针++;若cur指向的内容大于key,则cur指针直接++。如此进行下去,直到cur到达end位置,此时将key和++prev指针指向的内容交换即可。

    经过一次单趟排序,最终也能使得key左边的数据全部都小于key,key右边的数据全部都大于key。

    然后也还是将key的左序列和右序列再次进行这种单趟排序,如此反复操作下去,直到左右序列只有一个数据,或是左右序列不存在时,便停止操作

    //快速排序法  前后指针版本
    void QuickSort2(int* arr, int begin, int end)
    {
    	if (begin >= end)
    		return;
    	int cur = begin, prev = begin - 1;
    	int keyi = end;
    	while (cur != keyi)
    	{
    		if (arr[cur] < arr[keyi] && ++prev != cur)
    		{
    			swap(&arr[cur], &arr[prev]);
    		}
    		++cur;
    	}
    	swap(&arr[++prev],&arr[keyi]);
    	keyi = prev;
    	//[begin,keyi -1]keyi[keyi+1,end]
    	QuickSort2(arr, begin, keyi - 1);
    	QuickSort2(arr, keyi + 1, end);
    
    }
    
    展开全文
  • 个集合{4,6,5,8,2,1},我们可以用个8的二进制向量set[1-8]来表示该集合,如果数据存在,则将set相对应的二进制位置1,否则置0.根据给出的集合得到的set为{1,1,0,1,1,1,0,1},然后再根据set集合的值是否为1...

    位图排序是一种效率极高(复杂度可达O(n))并且很节省空间的一种排序方法,特点是用内存空间换取CPU时间。
    其原理是将一个bit当作一个数字,然后遍历,设置1为存在,0为不存在,然后顺序输出即可。
    例如:
    有一个集合{4,6,5,8,2,1},我们可以用一个8位的二进制向量set[1-8]来表示该集合,如果数据存在,则将set相对应的二进制位置1,否则置0.根据给出的集合得到的set为{1,1,0,1,1,1,0,1},然后再根据set集合的值是否为1输出对应的下标即可得到集合{1,2,4,5,6,8}。

    我本来打算使用位图排序来完成

    // 对1亿个随机数字进行排序(3秒)
        public static int[] getBitMap(int[] intArray) {
            // 获取数字数组的最大值
            int maxValue = intArray[0];
            for (int i = 0; i < intArray.length; ++i) {
                if (maxValue < intArray[i]) {
                    maxValue = intArray[i];
                }
            }
            // 设置位图数组bitMap的长度(位图数组长度 = 数字数组.maxValue + 1)
            byte[] bitmap = new byte[maxValue + 1];
            // 将数组转化为位图数组
            for (int i = 0; i < intArray.length; ++i) {
                int value = intArray[i];
                bitmap[value] = 1;
            }
    
            // 进行排序(倒序)
            int[] result = new int[intArray.length];
            int index = 0;
            for (int i = maxValue; i >= 0 & index < result.length; i--) {
                if (bitmap[i] == 1) {
                    result[index++] = i;
                }
            }
            return result;
        }
    
    
        public static void main(String[] args) {
    
            // 设置数组长度
            int[] intArray = new int[100000000];
            Random random = new Random();
            for (int i = 0; i < intArray.length; ++i) {
                // 随机生成数字
                intArray[i] = (int) (Math.random() * intArray.length);
            }
            // 测试时间
            System.out.println("Sort begin...");
            // 开始时间
            long current = System.currentTimeMillis();
            int[] result = Sort.getBitMap(intArray);
            //结束时间
            System.out.println("排序时间" + (System.currentTimeMillis() - current) + "ms");
            System.out.println("Sort end...");
    //        for (int i = 0; i < result.length; ++i) {
    //            System.out.print(result[i] + ",");
    //        }
    

    但是这种排序方法对输入的数据是有比较严格的要求:
    1.数据不能重复
    2.大致知道数据的范围

    当数据有重复时,排序就会出错(重复的数字都指向同一个“1”,所以最后只有“第一个”才能正确表示,其它都会变为默认值0)
    在这里插入图片描述
    在这里插入图片描述
    所以这种排序算法用在这感觉不太合适,大量数据排序好像都是通过将其拆分为很多小部分进行排序,然后最终在合并成一个排好序的整体。
    这里想问一下,这个问题有没有很好的解决方法啊。。。

    展开全文
  • 对一个二维数组中的数据排序,方法如下:  将整个数组中值最小的元素所在行调整为数组第行,  将除第行外的行中最小元素所在行调整为第2行,  将除第1,2行外的行中最小值元素所在行调整为第3行,以此类推 ...
    对一个二维数组中的数据排序,方法如下:
       将整个数组中值最小的元素所在行调整为数组第一行,
       将除第一行外的行中最小元素所在行调整为第2行,

       将除第1,2行外的行中最小值元素所在行调整为第3行,以此类推


    #include <stdio.h>

    #define N 4

    int FindMinLine(int Arr[][N], int CurrenLine)   //找到数组中从当前行开始的最小值所在行
    {
    int i = 0, j = 0;
    int min_index = 0;
    int min = 0;       //假设的最小元素
    min_index = CurrenLine;
    min = Arr[CurrenLine][0];

    for (i = CurrenLine; i < N; i++)
    {
    for (j = 0; j < N; j++)
    {
    if (min > Arr[i][j])
    {
    min = Arr[i][j];
    min_index = i;
    }
    }
    }
    return min_index;
    }

    void Swap(int Arr[][N], int CurrenLine, int MinLine) //交换当前行和最小值所在行
    {
    int i = 0;
    int temp = 0;

    for (i = 0; i < N; i++)
    {
    temp = Arr[CurrenLine][i];
    Arr[CurrenLine][i] = Arr[MinLine][i];
    Arr[MinLine][i] = temp;
    }
    }

    void Sort(int Arr[][N])  //对二维数组进行排序
    {
    int i = 0;
    int MinLine = 0; //最小行

    for (i = 0; i < N - 1; i++) //最后一次一定是排序好的,所以是N-1
    {
    MinLine = FindMinLine(Arr, i); //先找到最小值所在行
    Swap(Arr, i, MinLine); //交换当前行和最小值所在行
    }
    }

    void PrintArr(int Arr[][N])  //打印二维数组 
    {
    int i = 0;
    int j = 0;

    for (i = 0; i < N; i++)
    {
    for (j = 0; j < N; j++)
    {
    printf ("%d ", Arr[i][j]);
    }
    printf ("\n");
    }
    }

    int main()
    {
    int Arr[N][N] = {51,40,43,51,  6,5,48,9,  74,31,35,4,  86,15,64,165};

    Sort(Arr);
    PrintArr(Arr);

    return 0;
    }

    展开全文
  • 临近的数字两两进行比较,按照规定的顺序进行交换,,这样一趟过去后,最大或最小的数字就像气泡一样被‘排’最后一位,然后第二趟之后,次大或次小的数字被‘排’到倒数第二位,以此类推,直至第一位与第二位顺序正确。...
  • 基数排序(数字排序和英文字母排序)

    千次阅读 2019-09-14 11:54:37
    基本操作:先找出数据最大的位数,然后按照从低位(从高位)开始排序,收集已排序数据,直到最高(最低排序完成。 例如:先个位排序,再十位排序,然后依次是百位、千位,直到最高。 备注:基数排序有...
  • 八大排序算法

    万次阅读 多人点赞 2012-07-23 16:45:18
    排序有内部排序和外部排序,内部排序数据记录在内存中进行排序,而外部排序是因排序数据很大,次不能容纳全部的排序记录,在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。 当n较大,则...
  • 编写个汇编语言程序,实现先输入个0-100的数N,然后输入N个数,以回车结束每个数字并显示在屏幕上,再将未排序前和从小到大排序后的结果显示在屏幕上。实验结果应达到如下的个界面:**** 实验过程 本次汇编...
  • 海量数据排序

    2019-04-19 17:21:25
    海量数据排序 、外部排序 海量数据不能次性读入内存,在海量数据进行排序时,首先需要将海量数据拆分到多台机器或者多个文件,这些机器或文件称为拆分节点;然后在每个拆分节点上将数据全部读入内存并使用快速...
  • 文章详细总结了插入排序、希尔排序、选择排序、归并排序、交换排序(冒泡排序、快速排序)、基数排序、外部排序。从`思想`到`代码实现`。 大三党,大数据专业,正在为面试准备,欢迎学习交流`。
  • 5000数据排序

    2014-09-21 13:52:36
    完成5000数据排序,并显示运行时间。 二、实验环境 处理器:Intel Core2 Duo CPU 安装内存(RAM):4.00 GB 系统类型:64 windows7操作系统 IDE:Code::Blocks 12.11 编译器:GCC 4.7 三、实验内容 ...
  • 但是计数排序可以在基数排序的的算法范围来排序数据范围很大的数组。 步骤: 1、找到数据最小元素和最大元素 2、统计数组中每个值为i的元素出现的个数,存入计数数组第i项 3、所有的计数累加 4
  • sortlist = ["121","213","602","040"] sortlist.sort(key=lambda x: x[1]) print sortlist #['602', '213', '121', '040']
  • awk和sort 实现将前面的N-1个字段作为Key,最后一个字段做Value,并根据Value排序
  • 但插入排序一般来说是低效的,因为插入排序每次只能将数据移动一位 核心是设定一个gap,如下图中设定gap为4, 第一次将红色底,间隔为4位的数字排序 第二次将蓝色底,间隔为4位的数字排序 第三次将紫色低,间隔...
  • 最高优先(MSD)法:先按k1排序分组,再各组按k2排序分组,直到按最次kd分组后,再将各组连接起来,便得到个有序序列。 最低优先(LSD)法:先从kd开始分组,再kd-1进行排序,直到k1分组后得到个...
  • 本文是二分查找-模版III 的第题,后面的几道题的也算是本模版的微调版,加油~
  • 首先,创建个文件,里面每行输入数字 默认的排序方式是按照ASCII码进行升序 我们可以添加 -n 让它按照数字的大小进行升序 我们可以添加 -n -r 让它按照数字的大小进行降序 ...
  • 出处:http://www.imooc.com/qadetail/110187 function px() { var array1=["","二","三","四","五"];//这里的文字是随便起的 var array2 = [5, 4, 3, 2, 1]; var temp = 0;
  • 1.冒泡排序 冒泡排序 ...3.针对所有的元素重复以上的步骤,除了最后一个 4.持续每次越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较 5.稳定性:数值相同的元素在排序中不交换...
  • 最后一数字相同,则按每一行第一个数字为准从小到大排序 2877,xx,xx,xx,xx,xx,xx,10 2878,xx,xx,xx,xx,xx,1264 2880,xx,xx,xx,xx,xx,xx,6 2881,xx,xx,xx,xx,xx,xx,xx,248 2882,xx,1 2885,xx,xx,xx,xx,1 2886,xx...
  • 算法学习总结(2)——温故十大经典排序算法

    万次阅读 多人点赞 2019-08-29 14:57:51
    对一序列对象根据某个关键字进行排序。 1.2、排序术语 稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面;不稳定:如果a原本在b的前面,而a=b,排序之后a可能会出现在b的后面;内排序:所有排序操作都在...
  • 使用Pandas对数据进行筛选和排序

    千次阅读 2017-10-23 16:27:53
    筛选和排序是Excel中使用频率最多的功能,通过这个功能可以很方便的对数据表中的数据使用指定的条件进行筛选和计算,以获得需要的结果。在Pandas中通过.sort和.loc函数也可以实现这两 个功能。.sort函数可以实现...
  • 、直接插入 - 1.基本思路 - 2.代码实现 - 3.时间复杂度和空间复杂度 二、希尔排序 - 1.基本思路 - 2.代码实现 - 3.时间复杂度和空间复杂度 三、简单选择 - 1.基本思路 - 2.代码实现 - 3.时间复杂度和空间复杂度 四...
  • 海量数据排序问题

    2016-03-25 11:15:34
    问题:对于有9亿条不重复的11... 对于一些小伙伴来说可能上来就马上思考把所有数据导入到内存中,然后使用我们常用的快速排序,归并排序等,最后排序好的数据存入文件 。但是对于9亿条数据对于java来说个int
  • 如果有个已经有序的数据序列,要求在这个已经排好的数据序列中插入个数,但要求插入后此数据序列仍然有序,这个时候就要用到种新的排序方法——插入排序法,插入排序的基本操作就是将数据插入到已经排好序...
  • 排序的思想是将要排序数据分到几个有序的桶里,每个桶里的数据再单独进行排序最后将桶里的数据按照顺序依次取出。 时间复杂度分析:n个要排序数据均匀划分到m个桶内,每个桶里有k=nmk=\frac nmk=mn​个元素...
  • /*对一个数组奇数和偶数上的元素分别按照升序进行排序(共不超过100个数据)。 输入 行以0为结束标记的若干数据 [注意:有效数据不包含最后的结束标记0,且要求输入的有效数据中也不包含整数0] 输出 排序之后的...
  • 最近点问题中涉及到点按x或y进行升序排序,笔者尝试对排序方式进行优化。首先想到的自然是归并排序,毕竟归并排序的核心思想也是分治法,但是归并排序比较适合基数较多的情况。最后笔者更改思路如下:当点集合...
  • 快速排序(过程图解)

    万次阅读 多人点赞 2018-07-02 12:10:50
    假设我们现在“612 79345 108”这个10个数进行排序。首先在这个序列中随便找个数作为基准数(不要被这个名词吓到了,就是个用来参照的数,待会你就知道它用来做啥的了)。为了方便,就让第个数6作为基准数吧...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 287,115
精华内容 114,846
关键字:

对最后一位数字排序