精华内容
下载资源
问答
  • 快排思想

    千次阅读 2018-06-28 19:04:30
    转载于:http://developer.51cto.com/art/201403/430986.htm  感谢作者高省的排序算法有没有既不浪费空间又可以一点的排序算法呢?那就是“快速排序”啦!光听这个名字是不是就觉得很高端呢。假设我们现在对“6...

    转载于:http://developer.51cto.com/art/201403/430986.htm    感谢作者

    高快省的排序算法

    有没有既不浪费空间又可以快一点的排序算法呢?那就是“快速排序”啦!光听这个名字是不是就觉得很高端呢。

    假设我们现在对“6  1  2 7  9  3  4  5 10  8”这个10个数进行排序。首先在这个序列中随便找一个数作为基准数(不要被这个名词吓到了,就是一个用来参照的数,待会你就知道它用来做啥的了)。为了方便,就让第一个数6作为基准数吧。接下来,需要将这个序列中所有比基准数大的数放在6的右边,比基准数小的数放在6的左边,类似下面这种排列:

    3  1  2 5  4  6  9 7  10  8

    在初始状态下,数字6在序列的第1位。我们的目标是将6挪到序列中间的某个位置,假设这个位置是k。现在就需要寻找这个k,并且以第k位为分界点,左边的数都小于等于6,右边的数都大于等于6。想一想,你有办法可以做到这点吗?

    排序算法显神威

    方法其实很简单:分别从初始序列“6  1  2 7  9  3  4  5 10  8”两端开始“探测”。先从找一个小于6的数,再从找一个大于6的数,然后交换他们。这里可以用两个变量i和j,分别指向序列最左边和最右边。我们为这两个变量起个好听的名字“哨兵i”和“哨兵j”。刚开始的时候让哨兵i指向序列的最左边(即i=1),指向数字6。让哨兵j指向序列的最右边(即=10),指向数字。

    094811yilrz1tkzkvlrriz.png

    首先哨兵j开始出动。因为此处设置的基准数是最左边的数,所以需要让哨兵j先出动,这一点非常重要(请自己想一想为什么)。哨兵j一步一步地向左挪动(即j--),直到找到一个小于6的数停下来。接下来哨兵i再一步一步向右挪动(即i++),直到找到一个数大于6的数停下来。最后哨兵j停在了数字5面前,哨兵i停在了数字7面前。

    095430axy0qkhxxkktkktk.png

    095437kdandfxhbtokk2qh.png

    现在交换哨兵i和哨兵j所指向的元素的值。交换之后的序列如下:

    6  1  2  5  9 3  4  7  10  8

    095448k1kevwlz41373e7k.png

    095458ejza15wscjv7iw5c.png

    到此,第一次交换结束。接下来开始哨兵j继续向左挪动(再友情提醒,每次必须是哨兵j先出发)。他发现了4(比基准数6要小,满足要求)之后停了下来。哨兵i也继续向右挪动的,他发现了9(比基准数6要大,满足要求)之后停了下来。此时再次进行交换,交换之后的序列如下:

    6  1  2 5  4  3  9  7 10  8

    第二次交换结束,“探测”继续。哨兵j继续向左挪动,他发现了3(比基准数6要小,满足要求)之后又停了下来。哨兵i继续向右移动,糟啦!此时哨兵i和哨兵j相遇了,哨兵i和哨兵j都走到3面前。说明此时“探测”结束。我们将基准数6和3进行交换。交换之后的序列如下:

    3  1 2  5  4  6  9 7  10  8

    095506uz7e1uuukcblhkxv.png

    095514cag5fumuqqg5jnsw.png

    095530e0jf6p0y6aaaw2ir.png

    到此第一轮“探测”真正结束。此时以基准数6为分界点,6左边的数都小于等于6,6右边的数都大于等于6。回顾一下刚才的过程,其实哨兵j的使命就是要找小于基准数的数,而哨兵i的使命就是要找大于基准数的数,直到i和j碰头为止。

    OK,解释完毕。现在基准数6已经归位,它正好处在序列的第6位。此时我们已经将原来的序列,以6为分界点拆分成了两个序列,左边的序列是“3  1 2  5  4”,右边的序列是“9  7  10  8”。接下来还需要分别处理这两个序列。因为6左边和右边的序列目前都还是很混乱的。不过不要紧,我们已经掌握了方法,接下来只要模拟刚才的方法分别处理6左边和右边的序列即可。现在先来处理6左边的序列现吧。

    左边的序列是“3  1  2 5  4”。请将这个序列以3为基准数进行调整,使得3左边的数都小于等于3,3右边的数都大于等于3。好了开始动笔吧

    如果你模拟的没有错,调整完毕之后的序列的顺序应该是:

    2  1  3  5  4

    OK,现在3已经归位。接下来需要处理3左边的序列“2 1”和右边的序列“5 4”。对序列“2 1”以2为基准数进行调整,处理完毕之后的序列为“1 2”,到此2已经归位。序列“1”只有一个数,也不需要进行任何处理。至此我们对序列“2 1”已全部处理完毕,得到序列是“1 2”。序列“5 4”的处理也仿照此方法,最后得到的序列如下:

    1  2  3 4  5  6 9  7  10  8

    对于序列“9  7  10  8”也模拟刚才的过程,直到不可拆分出新的子序列为止。最终将会得到这样的序列,如下

    1  2  3 4  5  6  7  8 9  10

    到此,排序完全结束。细心的同学可能已经发现,快速排序的每一轮处理其实就是将这一轮的基准数归位,直到所有的数都归位为止,排序就结束了。下面上个霸气的图来描述下整个算法的处理过程。

    232129ogop8gk0r8y7l70k.png

    这是为什么呢?

    快速排序之所比较快,因为相比冒泡排序,每次交换是跳跃式的。每次排序的时候设置一个基准点,将小于等于基准点的数全部放到基准点的左边,将大于等于基准点的数全部放到基准点的右边。这样在每次交换的时候就不会像冒泡排序一样每次只能在相邻的数之间进行交换,交换的距离就大的多了。因此总的比较和交换次数就少了,速度自然就提高了。当然在最坏的情况下,仍可能是相邻的两个数进行了交换。因此快速排序的最差时间复杂度和冒泡排序是一样的都是O(N2),它的平均时间复杂度为O(NlogN)。其实快速排序是基于一种叫做“二分”的思想。我们后面还会遇到“二分”思想,到时候再聊。先上代码,如下

    1. #include <stdio.h> 
    2. int a[101],n;//定义全局变量,这两个变量需要在子函数中使用 
    3. void quicksort(int left,int right) 
    4.     int i,j,t,temp; 
    5.     if(left>right) 
    6.        return
    7.                                 
    8.     temp=a[left]; //temp中存的就是基准数 
    9.     i=left; 
    10.     j=right; 
    11.     while(i!=j) 
    12.     { 
    13.                    //顺序很重要,要先从右边开始找 
    14.                    while(a[j]>=temp && i<j) 
    15.                             j--; 
    16.                    //再找右边的 
    17.                    while(a[i]<=temp && i<j) 
    18.                             i++; 
    19.                    //交换两个数在数组中的位置 
    20.                    if(i<j) 
    21.                    { 
    22.                             t=a[i]; 
    23.                             a[i]=a[j]; 
    24.                             a[j]=t; 
    25.                    } 
    26.     } 
    27.     //最终将基准数归位 
    28.     a[left]=a[i]; 
    29.     a[i]=temp; 
    30.                              
    31.     quicksort(left,i-1);//继续处理左边的,这里是一个递归的过程 
    32.     quicksort(i+1,right);//继续处理右边的 ,这里是一个递归的过程 
    33. int main() 
    34.     int i,j,t; 
    35.     //读入数据 
    36.     scanf("%d",&n); 
    37.     for(i=1;i<=n;i++) 
    38.                    scanf("%d",&a[i]); 
    39.     quicksort(1,n); //快速排序调用 
    40.                              
    41.     //输出排序后的结果 
    42.     for(i=1;i<=n;i++) 
    43.         printf("%d ",a[i]); 
    44.     getchar();getchar(); 
    45.     return 0; 
    可以输入以下数据进行验证

    1061279345108

    运行结果是

    12345678910

    涨姿势环节

    快速排序由 C. A. R. Hoare(东尼霍尔,Charles Antony Richard Hoare)在1960年提出,之后又有许多人做了进一步的优化。如果你对快速排序感兴趣可以去看看东尼霍尔1962年在Computer Journal发表的论文“Quicksort”以及《算法导论》的第七章。快速排序算法仅仅是东尼霍尔在计算机领域才能的第一次显露,后来他受到了老板的赏识和重用,公司希望他为新机器设计一个新的高级语言。你要知道当时还没有PASCAL或者C语言这些高级的东东。后来东尼霍尔参加了由Edsger Wybe Dijkstra(1972年图灵奖得主,这个大神我们后面还会遇到的到时候再细聊)举办的“ALGOL 60”培训班,他觉得自己与其没有把握去设计一个新的语言,还不如对现有的“ALGOL 60”进行改进,使之能在公司的新机器上使用。于是他便设计了“ALGOL 60”的一个子集版本。这个版本在执行效率和可靠性上都在当时“ALGOL 60”的各种版本中首屈一指,因此东尼霍尔受到了国际学术界的重视。后来他在“ALGOL X”的设计中还发明了大家熟知的“case”语句,后来也被各种高级语言广泛采用,比如PASCAL、C、Java语言等等。当然,东尼霍尔在计算机领域的贡献还有很多很多,他在1980年获得了图灵奖。

    更多算法教程,请移步:

    http://ahalei.blog.51cto.com/


    展开全文
  • 经典快排思想,以及快排的改进

    千次阅读 2018-03-02 16:50:40
    经典快排思想 前提条件:给定一个无序数组arr 取这个数组最后一个数 num 作为标准,将前面部分的数分为两部分,使得&lt;=num的部分在左边,&gt;num的数在右边; 然后将最后一个数和&gt;num部分的第一...

    一.经典快排思想

    前提条件:给定一个无序数组arr
    1. 取这个数组最后一个数 num 作为标准,将前面部分的数分为两部分,使得<=num的部分在左边,>num的数在右边;
    2. 然后将最后一个数和>num部分的第一个数进行交换,就使得原本在数组最后位置的num找到了正确的位置,它的左边都是比它小的以及和它一样的数,右边都是比它大的数
    3. 回到1,进行递归或迭代,使得所有的数都找到正确的位

    二.通过荷兰国旗问题改进快排

    什么是荷兰国旗问题?

      已知一个整形数组arr,和一个整数num,请把小于num的数放在数组的左边,等于num的数放在数组的中间,大于num的数放在数组的右边。
    解决思路:
    遍历数组,
    1. 若比num小,当前位置和小于的最后一个位置+1的值交换,并当前位置++;
    2. 若比num大,当前位置和大于的第一个位置-1的值交换;
    3. 若等于num的值,当前位置++;
    附上代码:

    public static void NetherlandsFlag(int[] arr, int L, int R, int num) {
        int i = L;
        int p1 = L-1;
        int p2 = R+1;
    
        //终止条件:当前数的位置在大于区的前一个
        while(i < p2) {
            if(arr[i] < num) {
                //当前数比num小,放左边,i位置上的数和L上的数进行交换,并且i++,L++
                swap(arr, i++, ++p1);
            } else if(arr[i] == num) {
                //当前数和num相等,i++
                i++;
            } else {
                //当前数比num大,放右边,i位置上的数和R上的数进行交换,并且i++,R--
                swap(arr, i, --p2);
            }
        }
    }

      我们可以发现,荷兰国旗问题和经典快排不同的就只是将<=num改为了< num和=num两部分,借用这个思想使得原来每次只可以让一个数找到正确的位置改进为了每次至少让一个数找到位置。

    三.在这基础上将其改为随机快排

      随机快排改进的地方只是在选取数的时候,将每次都选取最后位置的数改为选取随机的一个数作为num,这样做的好处是什么呢?
    1. 选取最后一个数:如果是一个已经排好序的数组,每次找到位置之后,左边是要进行排序的部分,数组长度是原长度-1,它的时间复杂度就是O(N^2);如果每次找到的数都是中间的位置,它的时间复杂度就只有O(logN)
    2. 然而以随机数作为选取的标准num的时候,因为是随机的,就只能通过数学期望去计算它的时间复杂度,时间复杂度是O(logN)

    下面附上最终的快排代码及注释

    /*
     * swap(int[] arr, int i, int j);是将arr数组的i和j位置上的数交换的方法
     */
    public static void quickSort(int[] arr) {
        // 如果为空或长度为1不需要排序,直接返回
        if(arr == null || arr.length < 2)
            return;
        else
            quickSort(arr, 0, arr.length - 1);
    }
    
    // 递归排序
    public static void quickSort(int[] arr, int L, int R) {
        if(L < R) {
            /*
             * 随机快排的随机就在这
             * 是随机选取了一个数,和 R 进行了交换,然后使用这个数作为num,
             * 所以每次选取的num是随机的,
             * 在计算时间复杂度时,是没有最优最差情况的
             * 而是通过一个长期的数学期望计算的,结果是O(N*logN)
             */
            swap(arr, L + (int) (Math.random() * (R - L + 1)), R);
            int[] border = partition(arr, L, R);
    
            // 小于区和大于区进行递归
            quickSort(arr, L, border[0] - 1);
            quickSort(arr, border[1] + 1, R);
        }
    }
    
    // 将给定数组划分为小于区、等于区和大于区
    public static int[] partition(int[] arr, int L, int R) {
        int num = arr[R];
        int less = L - 1;
        int more = R + 1;
        int curr = L;
    
        // 分为小于区等于区和大于区
        while(curr < more) {
            if(arr[curr] < num) {
                swap(arr, curr++, ++less);
            } else if(arr[curr] > num) {
                swap(arr, curr, --more);
            } else {
                curr++;
            }
        }
    
        //返回等于区的左右边界的下标,通过下标确定小于区和大于区递归时的参数
        return new int[] {less + 1, more - 1};
    }
    
    展开全文
  • 求无序数组当中的中位数(快排思想,选中关键字,高低交替扫描) 示例: [@"1",@"9",@"6",@"8",@"3",@"2"] 输出: @"3" */ + (void)findMedianValue { NSMutableArray *array = [NSMutableArray ...

    /**

     求无序数组当中的中位数(快排思想,选中关键字,高低交替扫描)

     

     示例:

    [@"1",@"9",@"6",@"8",@"3",@"2"]

     

     输出:

    @"3"

     

     */

    + (void)findMedianValue {

        NSMutableArray *array = [NSMutableArray arrayWithObjects:@"1",@"9",@"6",@"8",@"3",@"2", nil];

        NSLog(@"输入数据:%@",array);

        NSInteger low = 0;

        NSInteger high = array.count - 1;

        

        NSInteger mid = high/2;

        NSInteger result = [self arraySort:array IndexStart:low IndexEnd:high];

        while(result != mid) {

            if (result < mid) {

                result = [self arraySort:array IndexStart:result+1 IndexEnd:high];

            }else {

                result = [self arraySort:array IndexStart:low IndexEnd:result-1];

            }

        }

        NSLog(@"中位数是:%@",array[mid]);

    }

     

    + (NSInteger)arraySort:(NSMutableArray *)array IndexStart:(NSInteger)indexStart IndexEnd:(NSInteger)indexEnd {

        

        NSInteger keyValue = [array[indexEnd] integerValue];

        NSInteger lastEnd = indexEnd;

        

        while (indexStart < indexEnd) {

            while (indexStart < indexEnd && [array[indexStart] integerValue] <= keyValue) {

                indexStart++;

            }

            while (indexStart < indexEnd && [array[indexEnd] integerValue] >= keyValue) {

                indexEnd--;

            }

            if (indexStart < indexEnd) {

                NSString *temp = array[indexStart];

                array[indexStart] = array[indexEnd];

                array[indexEnd] = temp;

            }

        }

        NSString *temp = array[indexEnd];

        array[indexEnd] = array[lastEnd];

        array[lastEnd] = temp;

        return indexStart;    

    }

     

    运行:

    展开全文
  • 这篇我们讲到了注明的荷兰旗问题,就是可以用到快排的思想~后续还有一系列的题目,应该都是可以用到快排思想的,后面慢慢整理ing~ 1. 题目描述 这个题目是由荷兰科学家Dijkstra提出来的,首先输入乱序排列的三色...

    基于快排思想的题目(一)——荷兰旗问题


        快排的实现大家估计都知道,主要就是一个partition和交换的过程。这个思想其实是很巧妙的,基于此,很多题目都可以用它来很好地解决。这篇我们讲到了注明的荷兰旗问题,就是可以用到快排的思想~后续还有一系列的题目,应该都是可以用到快排思想的,后面慢慢整理ing~


    1. 题目描述


       这个题目是由荷兰科学家Dijkstra提出来的,首先输入乱序排列的三色小球(红,白,蓝),如果通过两两交换,使得所有红色小球排在前面,白色小球排在中间,蓝色小球排在最后~



    2. 图文并茂来解答


        使用快排的思想,我们先用3个指针head, middle, tail。初始时,head和middle指向第一个球,tail指向最后一个球。然后移动和交换的规则如下:

    (0表示红,1表示白,2表示蓝)


    • middle指针所指元素为0时,与head指针所指的元素交换,而后middle++,head++ ;
    • middle指针所指元素为1时,不做任何交换(即球不动),而后middle++ ;
    • middle指针所指元素为2时,与tail指针所指的元素交换,而后,middle指针不动,tail-- 。
        直到current>tail, 停止移动。


    其实我们可以理解到:当middle指向0的时候,这个0应该是在前面的,所以说我们需要把它和head交换,交换之后自然head++,middle++,因为此时已经保证了head前面的都是0了;后面当middle指向2的时候,和上面原因一样,我们需要和tail交换,交换了之后只要把tail--,当时middle不要动,因为交换之后的数值我们还不知道情况呢,我们需要进一步判断。


    移动的图示如下:






    代码如下:

    #include<iostream>
    using namespace std; 
    
    void DutchFlag(int *a, int head, int middle, int tail)
    {
    	while(middle<=tail)
    	{
    		if(a[middle]==0)
    		{
    			swap(a[middle], a[head]); 
    			head++, middle++; 
    		}
    
    		if(a[middle]==1)
    			middle++; 
    
    		if(a[middle]==2)
    		{
    			swap(a[middle], a[tail]); 
    			tail--; 
    		}
    	}
    }
    
    int main()
    {
    	int a[10]={0, 1, 2, 1, 1, 2, 0, 2, 1, 0}; 
    	int num=10; 
    
    	for(int i=0; i<num; i++)
    		cout<<a[i]<<' '; 
    	cout<<endl; 
    
    	int head=0; 
    	int middle=0; 
    	int tail=num-1; 
    	
    	DutchFlag(a, head, middle, tail); 
    
    	for(int j=0; j<num; j++)
    		cout<<a[j]<<' '; 
    
    	return 0; 
    }







    展开全文
  • 寻找第K大的数(快排思想

    万次阅读 2016-04-15 22:27:19
    使用快排思想找第K大的数,算法复杂度O(n)。1.以数组a的第0位a[0]为参考基准base,将数组划分为两个部分; 如果找第K大的数,则将大于base的数往前挪,将小于base的数往后挪。如果找第K小的数,则与此相反。 ...
  • 数组中最大第K元素(快排思想)

    千次阅读 2017-05-19 19:06:02
    1. 利用快排的思想找数组中最大K元素,但是找到最大K元素 是排序后的数组 地址索引为K位置上的元素 ... 快排思想:  1.进行一次快排(将大的元素放在前半段,小的元素放在后半段), 假设得到的中轴为p=partition()
  • 298基于快排思想的查找 描述 借助于快速排序的算法思想,在一组无序的记录中查找给定关键字值等于key的记录。设此组记录存放于数组r[l…n]中。若查找成功,则输出该记录在r数组中的位置及其值,否则显示“not find...
  • 利用快排的思想寻找数组中第K大(小... 解题思路:首先了解快排思想,即每次可以将一个元素放到最终位置上,所以如果当前放置的元素是第K个位置,即得到了最终的结果,不用继续进行排序操作。所以有以下代码。 public
  • C++ 快排思想 求第k大的数据(2种思路)、第k小的数据(1种思路) #include&amp;lt;iostream&amp;gt; using namespace std; //找出数组中第k大的数 法1 二路快排1 int quicksort_k_big1(int a[], int l, ...
  • /* 一次快排完毕,这个中间数字是不是要寻找的数 */ if(num - i == k){ //如果是寻找第k小的数,则条件为 i == k break; } else if(num - i ){ //如果num - i 则说明我们要寻找的第k大的数在这个中间数字...
  • 查找第k小元素——运用快排思想

    千次阅读 2019-03-23 09:05:46
    在这里不讨论其他方法,运用快排思想来解题。根据快速排序的思想,当我们找到基准值时,便可以确定这个值是位于第几个位置的元素,因此可以利用这一思路找第 k 小元素。在分成的其他两个区间中,用类似二分的方法...
  • 快排思想实现单链表

    千次阅读 2014-09-08 15:51:36
    算法思想:对于一个链表,以head节点的值作为key,然后遍历之后的节点,可以得到一个小于key的链表和大于等于key的链表;由此递归可以对两个链表分别进行快速。这里用到了快速排序的思想即经过一趟排序能够将小于key...
  • 有一个整数数组,请你根据快速排序的思路,找...利用快排思想,取一个关键值,将其进行一趟快排之后,比它大的数都放到它左边,比他小的数都放到右边 要求第k大的数,就是求数组下标为k-1的数值 首先获取关键值的...
  • 关于利用快排思想求第K小数的分析

    千次阅读 2014-11-30 22:49:49
    最近复习快排算法,记得当时最有意思的是可以用快排的partition函数求出第K小数 于是上网搜索一番,发现都只是贴出了代码。无奈只好自己研究了下 利用快排partition求第k小数不得不从partition函数开始说: 快速...
  • //用快排思想:例如找49个元素里面第24大的元素,那么按如下步骤: //1.进行一次快排(将大的元素放在前半段,小的元素放在后半段), 假设得到的中轴为p //2.判断 k -1==p - low,如果成立,直接输出a[p],(因为...
  • 寻找第k大数(快排思想)

    千次阅读 2013-12-04 20:21:56
    剔除了相同的数,快排是从小到大排序的,所以k做了处理。 #include #include using namespace std; int hash[20000005]={0}; int A[10000005]; int counter=0; int k; int partition(int *A,int l,int r) { int...
  • 找数组中第k大的数,避免o(n2)时间,考虑快排方法。 #include #include using namespace std; int random_partion(int *p,int n) { int idx=rand()%n; //随机取划分元素 swap(p[idx],p[n-1]); //将划分元素...
  • 通过代码可以看出,和快排基本相似。 #include #include using namespace std; //在m个数中寻找最大的n个数 //将数组M[m]中的最大的n(n)个数放在数组前面 void search(int M[], int m, int n) { if (n ...
  • 上一节我讲了冒泡排序、插入排序、选择排序这三种排序算法,它们的时间复杂度都是 O(n2),比较高,适合小规模数据的排序。...我们可以借鉴这个思想,来解决非排序的问题,比如:如何在 O(n) 的时间复杂度内查...
  • 数字在排序数组中出现的次数 参与人数:1216时间限制:1秒空间限制:32768...统计一个数出现的次数,相当于在有序的序列里插入一个数,那么我只要确定插入的位置,利用快排思想,也可以说是二分,如果在数组中找
  • 找出第k大的数字   利用快速排序的思想,从数组S中随机找出一个元素X,把数组分为两部分Sa和Sb。Sa中的元素大于等于X,Sb中元素小于X。这时有两种情况: 1. Sa中元素的个数小于k,则Sb中的...
  • 记录一下快排思想

    千次阅读 2016-03-02 17:01:06
    简单记录一下简单的快排思想
  • 从n个无序的顺序表中找出第k小的数,采用快排思想: 先从n个元素中随便寻找一个数m作为分界点,m在列表中的位置为i 当 i = k时,m就是我们要寻找的第k小的数; 当 i > k时,我们就从1~i-1中查找; 当 i 实现代码...
  • 快排

    千次阅读 2019-03-05 15:37:19
    快排,i定为数组起始位置,j定为数组结束位置,x定为数组起始位置。不是随机快排,而随机快排的时间复杂度是n*lgn
  • 经典快排和随机快排

    千次阅读 2018-02-28 14:29:56
    * 经典快排、随机快排 * 经典快排:利用最后一个数作为分界点,小的放左边,大的放右边,可以使用荷兰国旗问题(文末)的方法优化 * 随机快排:产生一个随机位置作为分界点 */ import java.util.Arrays; public...
  • 图解快排

    千次阅读 2019-02-21 11:04:23
    开始 下面简单演示下如何用快排来实现下面数组从小到大排序 int arr[] = {2 4 1 8 4 0 3 6 2 5 8}; 首先什么都别想,跟着我一步一步的实现它 ...快排思想是选取一个关键字,所有比这个关键字大的放后面,比它小...
  • 快排求topk问题

    2019-09-06 18:07:43
    快排思想求topk问题 public static void main(String[] args) { int[] nums = new int[]{5, 3, 2, 10, 8, 1, 4, 9, 3, 12}; int topk = topk(nums, 0, nums.length -1, 3); System.out.print("\t...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 76,481
精华内容 30,592
关键字:

快排思想