快速排序计算第K大的数

最新推荐文章于 2022-03-06 23:56:30 发布
置顶 最新推荐文章于 2022-03-06 23:56:30 发布
阅读量8.7k 收藏 7
点赞数 7
分类专栏： 通用算法 java基础 文章标签： 快速排序 第K大的数 快排扩展应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/royal_lr/article/details/105074745
版权

        先说结论，最终版本代码如下：

public class KthNum {
    public static int k = 2;
    public static boolean bigK = false;

    public static void main(String[] args) {
        int arr[] = {3, 2, 3, 1, 7, 4, 5, 5, 6};
        int kNum = quickSort(arr);
        System.out.println("kNum=" + kNum);
    }

    public static int quickSort(int arr[]) {
        int length = arr.length;
        if (k <= 0 || k > length) throw new RuntimeException("K值不合理");
        int left = 0, right = length - 1;
        int p = -1;
        while (k != p + 1) {
            if (k < p + 1) {
                right = p - 1;
            } else if (k > p + 1) {
                left = p + 1;
            }
            p = partition(arr, left, right);
        }
        return arr[p];
    }

    public static int partition(int[] arr, int left, int right) {
        int pivot = arr[right];
        int sortIndex = left;
        for (int arrIndex = sortIndex; arrIndex < right; arrIndex++) {
            if (bigK ? arr[arrIndex] > pivot : arr[arrIndex] < pivot) {
                swap(arr, arrIndex, sortIndex);
                sortIndex++;
            }
        }
        swap(arr, sortIndex, right);
        return sortIndex;
    }

    public static void swap(int[] arr, int i, int j) {
        if (i == j) return;
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }


}

      还是老规矩，我会重点谈思路，到底是如何想出这段代码的，请往下看。

       熟悉快排的同学都知道，若不熟悉的同学，可以先看我的这篇白话解析快速排序。快排使用某一个数作为基准点进行分区，通常基准点左边的数都是小于基准点的，在基准点右边的数都是大于基准点的。

        例如1,3,4,2这组数字，使用快排以2为基准点进行倒序排序第一次的结果为3,4,2,1 ，如果你恰好是求第3大的数，那么就是基准点2，只用了一次排序，时间复杂度为O(n)。如果你是求第1大的数或者第2大的数，那么继续在基准点左边进行排序比较即可；如果你是求第4大的数，那么在基准点右边进行排序比较即可。细心的同学可以发现求第K大的数，K的值是和基准点的下标有关系的。第一次排序完成后，基准点2的下标为2，使用下标+1和K进行比较，若K等于下标+1直接返回当前下标的值；若K大于下标+1，则继续在基准点右边进行查找；若K小于下标+1，则继续在基准点左边进行查找。循环查找，直到K等于下标+1，则结束。

       基于以上的思路和对快排的理解，我们得出了计算第K大数的第一个版本1.0。

 1.0：

public class KthNum {
    public static void main(String[] args) {
        int arr[] = {3, 2, 3, 1, 7, 4, 5, 5, 6};
        int k = 2;
//        k=4;
        int kNum = quickSort(arr, 0, arr.length - 1, k);
        System.out.println("kNum=" + kNum);

    }

    public static int quickSort(int arr[], int left, int right, int k) {
        if (left >= right) return -1;
        int p = partition(arr, left, right);
        while (k != p + 1) {
            if (k < p + 1) {
                p = partition(arr, left, p - 1);
            } else if (k > p + 1) {
                p = partition(arr, p + 1, right);
            }
        }
        return arr[p];
    }

    public static int partition(int[] arr, int left, int right) {
        int pivot = arr[right];
        int sortIndex = left;
        for (int arrIndex = sortIndex; arrIndex < right; arrIndex++) {
            if (arr[arrIndex] > pivot) {
                swap(arr, arrIndex, sortIndex);
                sortIndex++;
            }
        }
        swap(arr, sortIndex, right);
        return sortIndex;
    }

    public static void swap(int[] arr, int i, int j) {
        if (i == j) return;
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

以上代码在K为2时，可以正常求出第2大的数为6,。但是当K为4时，会发生死循环。

那么为什么发生死循环:

思路1：

仔细查看while循环中 if 和 else if 中的代码，分析其执行过程如下：

上图是每一次执行完 partition 方法后，基准点的下标 p 的位置。通过分析第9次和第14次的执行结果，可以发现如果继续往下走就会进入9-13次的死循环。现在已经发现了问题，那么造成问题的原因是什么？

2个问题导致的：

     1. while循环中left 和  right 的值一直没发生变化

     2. 通过分析第8次的执行结果，可以发现2个相同的值5在比较时不会发生数据交换，这导致7, 6, 5, 4, 5, 3, 3, 2, 1 中的第4个数和第5个数无法形成有序的位置。

思路2：

      将while循环中的代码和快排中的代码对比会发现，在循环中 left 和  right 的值一直没发生变化的。初步估计会导致已经排过序的数下次循环会继续参与排序，从而导致死循环。

1.0小结：

主要是想通过复制粘贴的方式快速实现第K大数的方案，偷懒的心态导致了此版本中的死循环问题

 1.1：

··修复1.0版本中的死循环问题：

public class KthNum {
    public static void main(String[] args) {
        int arr[] = {3, 2, 3, 1, 7, 4, 5, 5, 6};
        int k = 2;
        k=4;
        int kNum = quickSort(arr, 0, arr.length - 1, k);
        System.out.println("kNum=" + kNum);

    }

    public static int quickSort(int arr[], int left, int right, int k) {
        if (left >= right) return -1;
        int p = partition(arr, left, right);
        while (k != p + 1) {
            if (k < p + 1) {
                p = partition(arr, left, p - 1);
            } else if (k > p + 1) {
                p = partition(arr, p + 1, right);
            }
        }
        return arr[p];
    }

    public static int partition(int[] arr, int left, int right) {
        int pivot = arr[right];
        int sortIndex = left;
        for (int arrIndex = sortIndex; arrIndex < right; arrIndex++) {
            if (arr[arrIndex] >= pivot) {
                swap(arr, arrIndex, sortIndex);
                sortIndex++;
            }
        }
        swap(arr, sortIndex, right);
        return sortIndex;
    }

    public static void swap(int[] arr, int i, int j) {
        if (i == j) return;
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }


}

修改了 partition 方法中第4行的代码，从 arr[arrIndex] > pivot 修改为 arr[arrIndex] >= pivot 。也就是在2个数相等时依然可以进行比较数据交换。

 2.0：

··修复1.0版本中的while循环中left 和  right 的值一直没发生变化导致死循环问题，也是我们的主线版本：

public class KthNum {
    public static void main(String[] args) {
        int arr[] = {3, 2, 3, 1, 7, 4, 5, 5, 6};
        int k = 2;
        k=4;
        int kNum = quickSort(arr, 0, arr.length - 1, k);
        System.out.println("kNum=" + kNum);

    }

    public static int quickSort(int arr[], int left, int right, int k) {
        if (left >= right) return -1;
        int p = partition(arr, left, right);
        while (k != p + 1) {
            if(k<p+1){
                right=p-1;
            }else if(k>p+1){
                left=p+1;
            }
            p=partition(arr,left,right);
        }
        return arr[p];
    }

    public static int partition(int[] arr, int left, int right) {
        int pivot = arr[right];
        int sortIndex = left;
        for (int arrIndex = sortIndex; arrIndex < right; arrIndex++) {
            if (arr[arrIndex] > pivot) {
                swap(arr, arrIndex, sortIndex);
                sortIndex++;
            }
        }
        swap(arr, sortIndex, right);
        return sortIndex;
    }

    public static void swap(int[] arr, int i, int j) {
        if (i == j) return;
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }


}

修改了 quickSort 方法中第5行和第7行的代码，将while循环中的 partition 方法调用放到了 if 外面，在 if 和 else if 中修改 left 和right 的值，这样使用快排计算第K大的数就基本实现了。

3.0：

这个版本是对2.0版本的优化：

public class KthNum {
    public static void main(String[] args) {
        int arr[] = {3, 2, 3, 1, 7, 4, 5, 5, 6};
        int k = 2;
        k=4;
        int kNum = quickSort(arr, 0, arr.length - 1, k);
        System.out.println("kNum=" + kNum);
    }

    public static int quickSort(int arr[], int left, int right, int k) {
        if (left >= right) return -1;
        int p=-1;
        while (k != p + 1) {
            if(k<p+1){
                right=p-1;
            }else if(k>p+1){
                left=p+1;
            }
            p=partition(arr,left,right);
        }
        return arr[p];
    }

    public static int partition(int[] arr, int left, int right) {
        int pivot = arr[right];
        int sortIndex = left;
        for (int arrIndex = sortIndex; arrIndex < right; arrIndex++) {
            if (arr[arrIndex] > pivot) {
                swap(arr, arrIndex, sortIndex);
                sortIndex++;
            }
        }
        swap(arr, sortIndex, right);
        return sortIndex;
    }

    public static void swap(int[] arr, int i, int j) {
        if (i == j) return;
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }


}

修改了 quickSort 方法中第2行的代码，这里的思路是 quickSort  方法中的第2行和第9行都调用了 partition 方法，我希望可以把它们统一起来，于是我给p赋值为-1，统一调用while循环中的partition方法。

4.0：

这个版本是对3.0版本的调整优化：

public class KthNum {
    public static int k = 4;

    public static void main(String[] args) {
        int arr[] = {3, 2, 3, 1, 7, 4, 5, 5, 6};
        int kNum = quickSort(arr);
        System.out.println("kNum=" + kNum);
    }

    public static int quickSort(int arr[]) {
        int length = arr.length;
        if (k <= 0 || k > length) throw new RuntimeException("K值不合理");
        int left = 0, right = length - 1;
        int p = -1;
        while (k != p + 1) {
            if (k < p + 1) {
                right = p - 1;
            } else if (k > p + 1) {
                left = p + 1;
            }
            p = partition(arr, left, right);
        }
        return arr[p];
    }

    public static int partition(int[] arr, int left, int right) {
        int pivot = arr[right];
        int sortIndex = left;
        for (int arrIndex = sortIndex; arrIndex < right; arrIndex++) {
            if (arr[arrIndex] > pivot) {
                swap(arr, arrIndex, sortIndex);
                sortIndex++;
            }
        }
        swap(arr, sortIndex, right);
        return sortIndex;
    }

    public static void swap(int[] arr, int i, int j) {
        if (i == j) return;
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }


}

优化点：

    1. 将 quickSort 方法的局部参数 left 和 right 放到方法内部赋值

    2. 移除了原quickSort 方法中 left 和 right  的比较

    3. quickSort 方法中添加了 K 值合理性的判断

4.0小结发散思考：

       至此，快排计算第K大的数就完成了。我们还是发散思考一下，既然第K大的数，那么肯定也有求第K小的数的需求。带着这个问题，我们重新审视一下上述4.0的代码，可以得出2种方案：

       1. 既然求第K大的数在while循环中可以通过K和P+1，在不同的区间范围排序查找。那么同理，求第K小的数也可以通过K和P的关系算出来。

       2. 上述 partition 方法中是通过倒序的方式求第K大的数，那么求第K小的数只需要采用升序的方式即可。

4.1：

这个版本就是4.0小结中的求第K小的数的第1种解决方案：

public class KthNum {
    public static int k = 3;
    public static boolean bigK = false;

    public static void main(String[] args) {
        int arr[] = {3, 2, 3, 1, 7, 4, 5, 5, 6};
        int kNum = quickSort(arr);
        System.out.println("kNum=" + kNum);
    }

    public static int quickSort(int arr[]) {
        int length = arr.length;
        if (k <= 0 || k > length) throw new RuntimeException("K值不合理");
        int left = 0, right = length - 1;
        int p = bigK ? -1 : partition(arr, left, right);
        while (k != (bigK ? p + 1 : length - p)) {
            if (bigK ? k < p + 1 : k > length - p) {
                right = p - 1;
            } else if (bigK ? k > p + 1 : k < length - p) {
                left = p + 1;
            }
            p = partition(arr, left, right);
        }
        return arr[p];
    }

    public static int partition(int[] arr, int left, int right) {
        int pivot = arr[right];
        int sortIndex = left;
        for (int arrIndex = sortIndex; arrIndex < right; arrIndex++) {
            if (arr[arrIndex] > pivot) {
                swap(arr, arrIndex, sortIndex);
                sortIndex++;
            }
        }
        swap(arr, sortIndex, right);
        return sortIndex;
    }

    public static void swap(int[] arr, int i, int j) {
        if (i == j) return;
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }


}

代码的改动是涉及K和P的关系的比较，属于一个逆势思维。在一串倒序的数中求第K小的数，例如在7, 6, 5, 5, 4, 3, 3, 2, 1 这组数中6是第2大的数，是第8小的数。有兴趣的可以看下，不过重点推荐5.0版本的实现方案。

5.0：

这个版本就是4.0小结中的求第K小的数的第2种解决方案：

public class KthNum {
    public static int k = 2;
    public static boolean bigK = false;

    public static void main(String[] args) {
        int arr[] = {3, 2, 3, 1, 7, 4, 5, 5, 6};
        int kNum = quickSort(arr);
        System.out.println("kNum=" + kNum);
    }

    public static int quickSort(int arr[]) {
        int length = arr.length;
        if (k <= 0 || k > length) throw new RuntimeException("K值不合理");
        int left = 0, right = length - 1;
        int p = -1;
        while (k != p + 1) {
            if (k < p + 1) {
                right = p - 1;
            } else if (k > p + 1) {
                left = p + 1;
            }
            p = partition(arr, left, right);
        }
        return arr[p];
    }

    public static int partition(int[] arr, int left, int right) {
        int pivot = arr[right];
        int sortIndex = left;
        for (int arrIndex = sortIndex; arrIndex < right; arrIndex++) {
            if (bigK ? arr[arrIndex] > pivot : arr[arrIndex] < pivot) {
                swap(arr, arrIndex, sortIndex);
                sortIndex++;
            }
        }
        swap(arr, sortIndex, right);
        return sortIndex;
    }

    public static void swap(int[] arr, int i, int j) {
        if (i == j) return;
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }


}

这里新增了一个成员变量 bigK 来做标识：true代表求第K大的数；false代表求第K小的数。同时在 partition 方法中的第4行也做了改动：若bigK为true，则采用倒序；若bigK为false，则采用升序。这样就以最小的改动实现了求第K大的数和第K小的数的需求，完美。

 

Royal_lr
关注
  • 7
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
算法：求第k小元素
05-25
学习算法时一个求第k小元素的小例子。内含代码和输入文件。很好用哦！
快速排序算法及得到数组中任意第K大的数
Lavi的专栏
12-28 1945
1 快速排序的图解 假设我们现在对6 1 2 7 9 3 4 5 10 8这个10个数进行排序。首先在这个序列中随便找一个数作为基准数（不要被这个名词吓到了，就是一个用来参照的数，待会你就知道它用来做啥的了）。为了方便，就让第一个数6作为基准数吧。接下来，需要将这个序列中所有比基准数大的数放在6的右边，比基准数小的数放在6的左边，类似下面这种排列。 3 1 2 5 4 6 9 7 10 8 在初始...
快速排序 寻找第K大的数
一只老风铃
09-15 1718
对于海量不确定数据，可采用维护大小为K的最小堆不断更新前K大的数 但对于数量有限的数组，可采用快速排序的思想寻找第K大的数，时间复杂度为O(lgN) 即快排之后， 若K刚好为基准点下标，那么返回基准点处的值 若K小于基准点，那么在前部分序列中递归查找 若K大于基准点，那么在后部分序列中递归查找 int Partition(int low, int high, int a[]) { ...
求n个数中前k大的数（排序）
holding,hold on...
03-23 9242
            这题两种思路，一种很直接的思路就快排，另一种是堆，我们来看下这两种算法的区别。第一种是快排，直接用快排将n个数排成有序，然后将前k大的数输出。平均时间复杂度为O（nlogn），空间复杂度为O（logn）。代码献上：public static void quickSort(int arr[],int k) {    Arrays.sort(arr);      for(int...
【算法】寻找第k大的数
bandaoyu的note
12-02 4781
目录： 1、引子 2、排序解决法 3、类快排解法 4、最小堆解法 1、引子 日常编码中，常见遇到这样的问题，“寻找最大的数”，此问题非常容易，可暴力直接遍历找出，也可使用分冶策略找出最大值（详见分冶算法）。 本文中需要寻找第k大的数，笔者目前想到3个方法可解决它。 2、排序解决法 如果是一个有序数组，那么寻找第k的大数则相当简单了，且效率为1。数组排序算法中相对较优的算法为快速排序，效率...
快速排序——寻找数组第K大数（由浅入深，四种方法对比讲解！）
热门推荐
不积跬步，无以至千里！
06-05 1万+
寻找数组第K大数是大厂面试中经常考到的一题，有的小机灵鬼直接用sort()进行排序，两行代码解决，这样看似可行，实则掉入了出题人的陷阱！
寻找第K大数的方法
csl13的专栏
12-05 2051
摘自：http://www.cnblogs.com/zhjp11/archive/2010/02/26/1674227.html 今天看算法分析是，看到一个这样的问题，就是在一堆数据中查找到第k个大的值。       名称是：设计一组N个数，确定其中第k个最大值，这是一个选择问题，当然，解决这个问题的方法很多，本人在网上搜索了一番，查找到以下的方式，决定很好，推荐给大家。 所谓“第（前）k大数问题”指的是在长度为n(n>=k)的乱序数组中S找出从大到小顺序的第（前）k个数的问题。       解法1
【LeetCode】快排-无序整数数组中找第k大的数(或者最小的k个数)
凝眸伏笔的博客
05-21 6771
一个有代表性的题目：无序整数数组中找第k大的数，对快排进行优化。 这里先不说这个题目怎么解答，先仔细回顾回顾快排，掰开了揉碎了理解理解这个排序算法：时间复杂度、空间复杂度；什么情况下是复杂度最高的情况。 1.主要思想 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据比另一部分的所有数据要小，再按这种方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，使整个数据变成有序序列。 快排是冒泡排序的改进，改进点：冒泡排序每次只能交换相邻的两个元素，而快速排序是跳跃式的交换，交换的
快速排序算法 数组中的第K个最大元素
TranSad的博客
03-06 839
215. 数组中的第K个最大元素 给定整数数组nums和整数k，请返回数组中第k个最大的元素。 请注意，你需要找的是数组排序后的第k个最大的元素，而不是第k个不同的元素。 示例 1: 输入:[3,2,1,5,6,4] 和k = 2输出:5 示例2: 输入:[3,2,3,1,2,4,5,5,6] 和k = 4输出:4 思路： 思路很简单，先对数组进行从大到小的排序，然后取排序后的第k个值就得到了第k个最大元素啦。 像这种排序就占了几乎全部解题过程的题目...
快速排序--可以实现求第k大数
qq_43637727的博客
02-05 255
/* 用快速排序实现求第k大数*/ #include <iostream> #include<stdio.h> using namespace std; int arr[100]; int Partition(int left,int right){ int random=rand()%(right-left)+left; swap(arr[left],arr[random]); while(left<right){ while(left<right&am
fastsum:一种尽快计算大型目录的安全校验和的工具
05-06
假设读取多个线程中的小文件可以使操作系统更有效地重新排序和处理请求，则文件工作线程数为16。 该代码还一次只允许一个线程读取大文件，前提是顺序读取一个大文件比中断在别处的按顺序读取要快。 （就fastsum而言...
并行计算课程设计（代码+执行文件+文档）
01-11
设处理器个数为p，数据量为n，由于正常情况下该快速排序算法的复杂度为O(nlogn),并行处理的时间复杂度为O(klogk),其中k=n/p,所以并行算法的时间复杂度为O((n/p)log(n/p)),理论加速比为nlogn/((n/p)log(n/p))=p+logp....
并行计算课程设计（报告+代码+可执行文件）
01-11
设处理器个数为p，数据量为n，由于正常情况下该快速排序算法的复杂度为O(nlogn),并行处理的时间复杂度为O(klogk),其中k=n/p,所以并行算法的时间复杂度为O((n/p)log(n/p)),理论加速比为nlogn/((n/p)log(n/p))=p+logp....
计算机算法设计与分析(共30张PPT).pptx
最新发布
05-28
12 舍伍德(Sherwood)算法 复习学过的Sherwood算法： （1）线性时间选择算法 （2）快速排序算法 有时也会遇到这样的情况，即所给的确定性算法无法直接改造成舍伍德型算法。此时可借助于随机预处理技术，不改变原有的...
高效的十进制与18进制的转换
Royal_lr的博客
08-11 1万+
十进制与18进制数的转换
java 栈 stack的应用场景
Royal_lr的博客
03-25 9496
栈的特性: 先进后出 1. 单链表，求倒数第K个数 public class MyNode { public Integer value; public MyNode next; public MyNode(Integer value) { this.value = value; } @Override public Stri...
快速排序进阶：解决经典面试topK问题
Royal_lr的博客
04-07 9465
不玩虚的，硬核干货快排解决topK，你值得拥有
如何生成指定范围内的随机数，要求稳定的时间复杂度？
Royal_lr的博客
08-25 9221
解决循环生成重复随机数的问题
非支配快速排序算法中的拥挤度计算公式
04-22
其中，Max_i和Min_i分别为第i个目标函数值最大和最小的个体在排序后经过第i个目标函数值排序后的第i个目标函数值，f_k^i代表第i个目标函数值为f_k的个体，m代表当前正在进行非支配快速排序的个体数，即m为已排序的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值