精华内容
下载资源
问答
  • 快速排序

    2016-04-21 10:45:04
    快速排序的基本思想是:选出一个关键字,通过一次遍历,把比关键字小的数据都放到关键字左边,把比关键字大的数据都放到关键字的右边。然后在左右两边依次进行快速排序快速排序的时间复杂度: 最坏的情况:所选...

    快速排序是冒泡排序的升级版,都是通过不断交换数据来进行排序。快速排序的基本思想是:选出一个关键字,通过一次遍历,把比关键字小的数据都放到关键字左边,把比关键字大的数据都放到关键字的右边。然后在对左右两边依次进行快速排序。

    由此可以看出,第一步关键字的选择很大程度上决定了快速排序的性能,如果关键字刚好选到了在中间左右的数据,那么经过一次排序后会把整段数据分成两段基本相等的数据,在进行下去效率就比较高;若果一不小心选择了最大或者最小的数据,那么一次排序下来相当于只排好了一个数据,相当不划算。为了提高性能,通常使用三数取中的方法来选取关键字,由于数据是随机排列的,可以分别在数组的左端、右端、和中间各取一个数,然后把最大的和最小的去掉,留下中间的值作为关键字,三个数同时都取得较大或者较小的概率比较小,因此可以接受。在部分情况下,还会用到九数取中的方法,就是分别取三组三个数,把三组的中数再作比较留下中间的值。

    快速排序是一种不稳定的排序,其时间复杂度为O(nlogn)空间复杂度为O(logn)~O(n)

    //快速排序函数
    //L[]为待排序序列,low为最低位的下标,high为最高位的下标
    void QuickSort(int L[], int low, int high)
    {
        int middle = 0;                   //middle为关键字返回的下标
        while (low < high) {
            middle = Partition(L,low,high);  //把关键字排好位置返回其下标
            QuickSort(L, low, middle - 1);       //对关键字左边的部分进行递归快速排序
            low = middle + 1;              //对关键字右边的部分进行递归快速排序
            
        }
    }

    //将关键字排好顺序,这是快速排序中最重要的步骤
    //L[]为待排序序列,low为最低位的下标,high为最高位的下标
    int Partition(int L[],int low, int high)
    {
        int middlekey = 0;
        
        //首先通过三数取中算法得到比较中值得关键字
        int m = low + (high - low) / 2;      //计算数组中间元素下标
        if(L[low] > L[high])
        {
            swap(L, low, high);       //保证高位得数比低位的大
        }
        
        if(L[m] > L[high])
        {
            swap(L, m, high);         //保证高位得数比中间的的大
        }
        
        if (L[low] < L[m])
        {
            swap(L, low, m);          //把三个数的中间值放在L[low]的位置上
        }
        
        middlekey = L[low];
        L[0] = middlekey;             //把选出来的中值备份到L[0]的位置上
        while (low < high && L[high] >= middlekey)    //当后面的值一直比中值打,则不用交换,high向前移动
        {
            high--;
        }
        
        //如果跳出while循环则代表高位的值比中值小,把高位的值覆盖到低位
        L[low] = L[high];             //此函数返回的是中值的下标,因此数据替换掉没有关系
       
        
        //对低位的处理和高位一样
        while (low < high && L[low] <= middlekey)
        {
            low++;
        }
        L[high] = L[low];
        L[low] = L[0];
        return low;
        
    }
    

    快速排序的时间复杂度:

    最坏的情况:所选的关键字每次都是最大值或者最小值,这样的话快速排序就成了冒泡排序,时间复杂度为O(n^2)

    最优/平均情况:第一次调用partition将整个数组扫描一遍,做n次比较。递归logn次,所以时间复杂度为O(nlogn)


    空间复杂度:

    最坏情况:进行n - 1次递归调用,其空间复杂度为O(n)

    平均情况:O(logn)


    展开全文
  • 快速排序总结

    2018-08-15 21:56:47
    快速排序,从字面意思就可以看出这是一种效率比较高的排序算法,现在该算法一下总结: 快速排序是由冒泡排序改进而得的,它的基本思想是:在待排序的n个记录中任取一个记录(通常取第一个记录),把该记录放...

    快速排序,从字面意思就可以看出这是一种效率比较高的排序算法,现在对该算法做一下总结:

    快速排序是由冒泡排序改进而得的,它的基本思想是:在待排序的n个记录中任取一个记录(通常取第一个记录),把该记录放入适当位置后,数据序列被此记录划分成两部分。所有关键字比该记录关键字小的记录放置在前一部分,所有比它大的记录放置在后一部分,并把该记录排在这两部分的中间(称为该记录归位),这个过程称作一趟快速排序。之后对所有的两部分分别重复上述过程,直至每个部分内只有一个记录或为空为止。简单的说,每趟使表的第一个元素放入适当位置,将表一分为二,对子表按递归方法继续这种划分,直至划分的子表长为1或0.

    1、挖坑法找基准值

    基本思路:
    1、寻找pos位,然后将其分为两段数组,然后对这两段数组递归排序;
    2、指定一个基数key(三数取中法),定义两个下标begin指向起始位置,end指向最后一个元素的位置。begin寻找比基数(key)大的数字,找到 后将begin的数据赋给end,begin成为一个坑,然后end寻找比基数(key)小的数字,找到将end的数据赋给begin,end成为一个新坑,循环这个过程,直到begin指针与end指针相遇,然后将key的数据返回给那个坑,然后进行递归操作。

    int Pation1(int *array, int left, int right)
    {
        int begin = left;
        int end = right;
        int key = array[left];
        while (begin < end)
        {
            while (begin < end &&array[end] >= key)
                end--;
            if (begin < end)
            {
                array[begin++] = array[end];
            }
            while (begin < end&&array[begin] < key)
                begin++;
            if (begin< end)
            {
                array[end] = array[begin];
                end--;
            }
        }
        array[begin] = key;
        return begin;
    }

    2、前后指针法找基准值

    基本思路:
    定义两个指针:pPre和pCur,pPre指针找比基准值大的数,pCur指针找比基准值小的数,pPre找到后,将pPre和pCur指针所指向的数据交换,当pPre指针遍历完整个数组时,将基数值与pCur指针的后一个位置的数据进行交换,然后以pCur指针的后一个位置作为分界,然后将数组分开,进行递归排序。
    代码实现:

    int Pation2(int*array, int left, int right)
    {
    
        int pCur = left;//找大数
        int prev = pCur - 1;//找小数
        int key = array[right];
        while (pCur <= right)
        {
            if (array[pCur] <= key&&++prev != pCur)
                swap(array[prev], array[pCur]);
            pCur++;
        }
        return prev;
    }

    3、分而治之法

    基本思路:
    1.先从数列中取出一个数作为基准数。
    2.分区过程,将比这个数大的数全放到它的右边,小于或等于它的数全放到它的左边。
    3.再对左右区间重复第二步,直到各区间只有一个数。
    代码实现:

    int Pation3(int *array, int left, int right)
    {
        int begin = left;
        int end = right;
        int key = array[end];
        while (begin < end)
        {
            while (begin < end&&array[begin] <= key)
                begin++;
            while (begin<end&&array[end]>key)
                end--;
            if (begin < end)
            {
                swap(array[begin], array[end]);
                begin++;
                end--;
            }
        }
        if (begin != right&&array[begin]>array[right])
        {
            swap(array[begin], array[end]);
            return begin;
        }
        return right;
    }

    4、整体代码

    //递归写法
    void QuickSort(int *array, int left,int right)
    {
        if (left < right)
        {
            int div = Pation1(array, left, right);
            QuickSort(array, left, div-1);
            QuickSort(array, div + 1, right);
    
        }
    }
    //非递归写法
    //快排的非递归写法
    void QuickSort_O(int *array, int size)
    {
        int left = 0;
        int right = size;
        stack<int> s;
        s.push(right);
        s.push(left);
        while (!s.empty())
        {
            left = s.top();
            s.pop();
            right = s.top();
            s.pop();
            if (left < right)
            {
                int div = Pation3(array, left, right);
                //保存右半部分区间
                s.push(right);
                s.push(div+1);
                //保存左半部分区间
                s.push(div);
                s.push(left);
            }
        }
    }
    
    void show(int*array,int size)
    {
        for (int i = 0; i < size; i++)
            cout << array[i] << " ";
        cout << endl;
    }
    void SortTest()
    {
        int arr[10] = { 6, 5, 1, 3, 8, 9, 7, 2, 0, 4 };
        int sz = sizeof(arr) / sizeof(arr[0]);
        QuickSort(arr, 0, sz - 1);
        show(arr, sz);
    
    }
    int main()
    {
        SortTest();
        system("pause");
        return 0;
    }

    5、快排优化

    在选择基准值的时候,我们可能会因为选取的数太大或者太小,造成左右区间不均匀,这样就会影响程序的效率和性能,这时候呢,我们可以采取三数取中法来决定基准值:
    代码实现:

    int GetKeyIdx(int arr[], int left, int right)
    {
        int mid = right - ((right - left) >> 1);
        if (arr[left] < arr[right])
        {
            if (arr[mid] < arr[left])
                return left;
            else if (arr[mid]>arr[right])
                    return right;
                else
                    return mid;
        }
        else
        {
            if (arr[mid] < arr[right])
                return right;
            else if (arr[mid]>arr[left])
                    return left;
                else
                    return mid;
        }
    }

    6、算法性能分析

    时间复杂度:
    最优情况:O( nlogn)(即区间分配比较均匀)
    最差情况:O( n^2 ) ( 最差的情况就是每一次取到的元素就是数组中最小/最大的,这种情况其实就是冒泡排序了(每一次都排好一个元素的顺序))
    平均时间复杂度:O( nlogn)
    空间复杂度:
    最优的情况下空间复杂度为:O(logn) ,每一次都平分数组的情况
    最差的情况下空间复杂度为:O( n ) ,退化为冒泡排序的情况
    稳定性:
    是不稳定排序
    以上就是对快排的简单总结啦,希望对你有帮助。

    展开全文
  • 排序算法之交换排序(冒泡排序和快速排序) 交换排序:根据序列两元素关键字的比较结果来对换两记录在序列中的位置。 冒泡排序 原理如下 比较相邻的元素。如果第一比第二大,就交换他们两每一对...

    排序算法之交换排序(冒泡排序和快速排序)

    交换排序:根据序列两个元素关键字的比较结果来对换两个记录在序列中的位置。

    冒泡排序

    原理如下

    1. 比较相邻的元素。如果第一个比第二个大,就交换他们两个。

    2. 对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。

    3. 针对所有的元素重复以上的步骤,除了最后一个。

    4. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

      时间复杂度最好o(n)最坏o(n2)

      空间复杂度o(1)

      代码实现(c)

      #include <stdio.h>
      #include <stdbool.h>
      
      void BubbleSort (int a[],int n){  //冒泡排序 
      	int i,j,temp;         
      	for( i=0;i<n-1;i++){
      		bool flag=false;      //表示本趟冒泡是否发生交换的标志 
      		for( j=n-1;j>1;j--)   //一趟冒泡的过程 
      		if(a[j-1]>a[j]){      //后面的数小于前面的 进行交换 
      			temp=a[j];
      			a[j]=a[j-1];
      			a[j-1]=temp;
      			flag=true;    
      		}
      		if(flag==false)    //本趟遍历没有发生交换说明结束 
      		return;
      	}
      }
      void Printarr(int a[],int n)    //输出数组 
      {
      	int i;
      	for(i=0;i<n;i++){
      		printf("%d",a[i]);
      	}
      	return;
      } 
      
      int main(){                //主函数 
      	int b,c;
      	int a[]={1,8,7,5,6};
      	int n=5;
      	printf("未排序的数\n"); 
      	Printarr(a,n);
      	printf("\n");
      	BubbleSort(a,n);
      	printf("冒泡排好序的数\n");
      	Printarr(a,n);
      	return 0;
      }
      

    快速排序

    通过一趟排序将待排记录分隔成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序。
    代码实现c

    #include <stdio.h>
    #include <stdlib.h>
    
    int getStandard(int array[], int i, int j) {
    	//基准数据 
    	int key = array[i];
    	while (i < j) { 	//因为默认基准是从左边开始,所以从右边开始比较 //当队尾的元素大于等于基准数据 时,就一直向前挪动 j 指针 
    			while (i < j && array[j] >= key) {
    				j--;
    			}
    			if (i < j) {
    				array[i] = array[j];//当找到比 array[i] 小的时,就把后面的值 array[j] 赋给它
    			}	
    			while (i < j && array[i] <= key) {//当队首元素小于等于基准数据 时,就一直向后挪动 i 指针 
    				i++;
    			}
    			//当找到比 array[j] 大的时,就把前面的值 array[i] 赋给它
    			if (i < j) {
    				array[j] = array[i];
    			}
    		}
    	array[i] = key;//跳出循环时 i 和 j 相等,此时的 i 或 j 就是 key 的正确索引位置
    	return i;//把基准数据赋给正确位置 
    }
    void QuickSort(int array[], int low, int high) {
    	//开始默认基准为 low
    	if (low < high) {
    		//分段位置下标 
    		int standard = getStandard(array, low, high);
    		//递归调用排序
    		//左边排序 
    		QuickSort(array, low, standard - 1);
    		//右边排序 
    		QuickSort(array, standard + 1, high);
    	}
    }
    
    void display(int array[], int size) {
    	int i;
    	for (i = 0; i < size; i++) {
    		printf("%d ", array[i]);
    	}
    	printf("\n");
    }
    
    int main() {
    	int array[] = { 49,38,65,97,76,13,27,49,10 };
    	int size = sizeof(array) / sizeof(int);
    	QuickSort(array, 0, size - 1);
    	printf("排好的顺序为") ; 
    	display(array, size);
        return 0;
    }
    

    在这里插入图片描述

    时间复杂度O(n*递归的层数)空间复杂度O(递归的层数)

    层数最小(log2n)最大n

    优化的思路选取基轴元素时选头 中 尾三个比较选中间或者随机选一个数作为基轴

    时间复杂度O(n*递归的层数)空间复杂度O(递归的层数)

    层数最小(log2n)最大n

    优化的思路选取基轴元素时选头 中 尾三个比较选中间或者随机选一个数作为基轴

    展开全文
  • 6、算法分析快速排序的时间主要耗费在划分操作上,长度为k的区间进行划分,共需k-1次关键字的比较。(1)最坏时间复杂度最坏情况是每次划分选取的基准都是当前无序区中...因此,快速排序必须做n-1次划分,第i次...
    6、算法分析
      快速排序的时间主要耗费在划分操作上,对长度为k的区间进行划分,共需k-1次关键字的比较。
      (1)最坏时间复杂度
      最坏情况是每次划分选取的基准都是当前无序区中关键字最小(或最大)的记录,划分的结果是基准左边的子区间为空(或右边的子
      区间为空),而划分所得的另一个非空的子区间中记录数目,仅仅比划分前的无序区中记录个数减少一个。
      因此,快速排序必须做n-1次划分,第i次划分开始时区间长度为n-i+1,所需的比较次数为n-i(1≤i≤n-1),故总的比较次数达
      到最大值:
      C max = n(n-1)/2=O(n 2 )
      如果按上面给出的划分算法,每次取当前无序区的第1个记录为基准,那么当文件的记录已按递增序(或递减序)排列时,每次划分
      所取的基准就是当前无序区中关键字最小(或最大)的记录,则快速排序所需的比较次数反而最多。
      (2) 最好时间复杂度
      在最好情况下,每次划分所取的基准都是当前无序区的"中值"记录,划分的结果是基准的左、右两个无序子区间的长度大致相等
      。总的关键字比较次数:
      0(nlgn)
      注意:
      用递归树来分析最好情况下的比较次数更简单。因为每次划分后左、右子区间长度大致相等,故递归树的高度为O(lgn),而递归
      树每一层上各结点所对应的划分过程中所需要的关键字比较次数总和不超过n,故整个排序过程所需要的关键字比较总次数
      C(n)=O(nlgn)。
      因为快速排序的记录移动次数不大于比较的次数,所以快速排序的最坏时间复杂度应为0(n 2 ),最好时间复杂度为O(nlgn)。
      (3)基准关键字的选取
      在当前无序区中选取划分的基准关键字是决定算法性能的关键。
      ①"三者取中"的规则
      "三者取中"规则,即在当前区间里,将该区间首、尾和中间位置上的关键字比较,取三者之中值所对应的记录作为基准,在划分
      开始前将该基准记录和该区伺的第1个记录进行交换,此后的划分过程与上面所给的Partition算法完全相同。
      ②取位于low和high之间的随机数k(low≤k≤high),用R[k]作为基准
      选取基准最好的方法是用一个随机函数产生一个取位于low和high之间的随机数k(low≤k≤high),用R[k]作为基准,这相当于
      强迫R[low..high]中的记录是随机分布的。用此方法所得到的快速排序一般称为随机的快速排序。具体算法【参见教材】
      注意:
      随机化的快速排序与一般的快速排序算法差别很小。但随机化后,算法的性能大大地提高了,尤其是对初始有序的文件,一般不
      可能导致最坏情况的发生。算法的随机化不仅仅适用于快速排序,也适用于其它需要数据随机分布的算法。
      (4)平均时间复杂度
      尽管快速排序的最坏时间为O(n 2 ),但就平均性能而言,它是基于关键字比较的内部排序算法中速度最快者,快速排序亦因此
      而得名。它的平均时间复杂度为O(nlgn)。
      (5)空间复杂度
      快速排序在系统内部需要一个栈来实现递归。若每次划分较为均匀,则其递归树的高度为O(lgn),故递归后需栈空间为O(lgn)。
      最坏情况下,递归树的高度为O(n),所需的栈空间为O(n)。
      (6)稳定性
      快速排序是非稳定的,例如[2, 2 ,1]。

    转载于:https://www.cnblogs.com/zhiji6/archive/2009/11/11/1649234.html

    展开全文
  • 冒泡排序(bubble sort) 的算法思想是:设数据表elem中有n个数据元素,首先数据表中第一、二个数据元素(elem[0]和 clem[1])进行比较,如果 elem[0]>eicm[1],则交换 elcm[0]和 elem[1];然后第二、三个...
  • 如果排序n个关键字,其递归树的深度就为 [log2n]+1( [x] 表示不大于 x 的最大整数),即仅需递归 log2n 次,需要时间为T(n)的话,第一次Partiation应该是需要整个数组扫描一遍,n次比较。然后,获得的枢轴将...
  • 八大排序算法有:冒泡排序、插入排序、选择排序、快速排序、希尔排序、堆排序、归并排序、基数排序。前面七种网上都有很多例子,但是最后一种基数排序...基数排序所的事情,是对N位分别进行排序。从直觉上来看,人...
  • //使用快速排序方法a[ 0 :n- 1 ]排序 从a[ 0 :n- 1 ]中选择一元素作为m i d d l e,该元素为支点 把余下的元素分割为两段left 和r i g h t,使得l e f t中的元素都小于等于支点,而right 中的元素都大于...
  • 你上了公交车发现前排有两空座位,而后排所有座位都已经坐满,你会怎么?立马下车,并自己说,后面没座了,我等下一辆?没这么笨的人,前面有座位,当然也是可以坐的。 4.12.1队列顺序存储的不足 112 4.12.2...
  • 例如定义一个包含N个指向返回指向字符的指针的函数的指针的数组? 1.22 如何声明返回指向同类型函数的指针的函数?我在设计一个状态机,用函数表示每种状态,每个函数都会返回一个指向下一个状态的函数的指针。可我...
  • 例如定义一个包含N个指向返回指向字符的指针的函数的指针的数组? 11  1.22 如何声明返回指向同类型函数的指针的函数?我在设计一个状态机,用函数表示每种状态,每个函数都会返回一个指向下一个状态的函数的指针...
  • 《你必须知道的495C语言问题》

    热门讨论 2010-03-20 16:41:18
    例如定义一个包含N个指向返回指向字符的指针的函数的指针的数组? 11  1.22 如何声明返回指向同类型函数的指针的函数?我在设计一个状态机,用函数表示每种状态,每个函数都会返回一个指向下一个状态的函数的指针...
  • 数字进行排序.cmd 局域网扫描批处理.txt 屏幕炸弹.bat 建立回收站.cmd 弹出对话框.bat 快速清理垃圾文件.bat 感情进度条.bat 感情进度条.cmd 打开控制面板中的某项.cmd 打开系统属性.cmd 批处理加密.bat 批处理...
  • 数字进行排序.cmd 把一数拆分为几数的和.cmd 无限制实数加减运算脚本.cmd 显示随机的5数.cmd 水仙花数算法.cmd 求一列数所有不同组合的和.cmd 求最大公约数和最小公倍数.cmd 生成0-99之间的随机数列....
  • 入门学习Linux常用必会60命令实例详解doc/txt

    千次下载 热门讨论 2011-06-09 00:08:45
    n:一般而言,mount挂上后会在/etc/mtab中写入一笔资料,在系统中没有可写入文件系统的情况下,可以用这选项取消这动作。 4.应用技巧 在Linux 和Unix系统上,所有文件都是作为一大型树(以/为根)的一部分...
  • 你必须知道的495C语言问题(PDF)

    热门讨论 2009-09-15 10:25:47
    例如定义一包含N 指向返 回指向字符的指针的函数的指针的数组? . . . . . . . . . . . . . . 3 1.8 函数只定义了一次, 调用了一次, 但编译器提示非法重定义了。. . 4 1.9 main() 的正确定义是什么? void main...
  • 3.1 保证了不同线程变量进行操作时的可见性,即一线程修改了某个变量的值,这新值其他线程来说是立即可见的。(保证可见性) 3.2 禁止进行指令重排序。(保证有序性) 划重点:volatile 关键字能保证...
  • 大话数据结构

    2019-01-10 16:35:22
    你上了公交车发现前排有两空座位,而后排所有座位都已经坐满,你会怎么?立马下车,并自己说,后面没座了,我等下一辆?没这么笨的人,前面有座位,当然也是可以坐的。 4.12.1队列顺序存储的不足 112 4.12.2...
  • 大话数据结构 程杰

    2018-09-01 10:06:43
    你上了公交车发现前排有两空座位,而后排所有座位都已经坐满,你会怎么?立马下车,并自己说,后面没座了,我等下一辆?没这么笨的人,前面有座位,当然也是可以坐的。 4.12.1队列顺序存储的不足 112 4.12.2...
  • 4.11 队列的抽象数据类型 112 4.12 循环队列 113 你上了公交车发现前排有两空座位,而后排所有座位都已经坐满,你会怎么?立马下车,并自己说,后面没座了,我等下一辆?没这么笨的人,前面有座位,当然也是...
  • 你上了公交车发现前排有两空座位,而后排所有座位都已经坐满,你会怎么?立马下车,并自己说,后面没座了,我等下一辆?没这么笨的人,前面有座位,当然也是可以坐的。 4.12.1队列顺序存储的不足 112 4.12.2...
  • 大话数据结构-程杰

    2014-07-13 23:45:52
    你上了公交车发现前排有两空座位,而后排所有座位都已经坐满,你会怎么?立马下车,并自己说,后面没座了,我等下一辆?没这么笨的人,前面有座位,当然也是可以坐的。 4.12.1 队列顺序存储的不足 112 ...
  • 数据结构(C++)有关练习题

    热门讨论 2008-01-02 11:27:18
    3、从终端读入字符集大小为n(即字符的个数),逐一输入n个字符和相应的n个权值(即字符出现的频度),建立哈夫曼树,进行编码并且输出。 注:可用C或C++编写。 4、用邻接矩阵或邻接图实现一个有向图的...
  • 一列中的文字统一去掉最后一字 讨如何去掉单元格中的第一数字? 论一下取最后一单词的方法 如何去掉单元格最后一位数字 如何在一列已经输入的数据前添加“p” 什么函数可以插入字符 如何在数据前添加“*”号...
  • Collections是针对集合类的一帮助类,他提供一系列静态方法实现各种集合的搜索、排序、线程安全化等操作。 13、&和&&的区别。 &是位运算符,表示按位与运算,&&是逻辑运算符,表示逻辑与(and)。 14、...
  • EXCEL函数公式集

    热门讨论 2010-03-16 03:26:38
    一列中的文字统一去掉最后一字 讨如何去掉单元格中的第一数字? 论一下取最后一单词的方法 如何去掉单元格最后一位数字 如何在一列已经输入的数据前添加“p” 什么函数可以插入字符 如何在数据前添加“*”号...
  • 数据结构课设

    2013-01-03 02:51:25
    任务 :利用随机函数产生10样本(其中之一已为正序,之一为倒序),每样本有20000随机整数,利用直接插入排序、希尔排序,冒泡排序、快速排序、选择排序、堆排序,归并排序(递归和非递归),基数排序八种排序...

空空如也

空空如也

1 2 3
收藏数 60
精华内容 24
关键字:

对n个关键字做快速排序