快速选择
用于求解 Kth Element 问题，也就是第 K 个元素的问题。
可以使用快速排序的 partition() 分治进行实现。需要先打乱数组，否则最坏情况下时间复杂度为 O(N2)。
关于快速排序：
https://blog.csdn.net/nrsc272420199/article/details/82587933（例子和总结很好，是评论区说代码有问题0改成low，但是换成low我反而不理解了。。。嗷，理解了，后半段可能还需要分两段，后半段分两段后的前半段就不是从0开始了）
https://blog.csdn.net/morewindows/article/details/6684558 （这个也好理解，挖坑填数最后分治）
1个temp存第一个元素的数据作为基准数，排他！！！一个low指针的数据，还有一个high指针从尾部开始。
首先从后面hign指针开始，如果nums[high] 大于temp(后面没有值对应的变量名，用索引代替)，则high-1左移。若nums[high]小于temp则把nums[high]赋值给nums[low],即nums[low]=nums[high] ，赋值的话high不动不用左移！！ 是赋值给nums[low]不是temp！！！！temp是不变的一直是第一个元素的值！！！
前边nums[low]要是被后面小的nums[high]赋值以后的话，就要low指针右移1位，开始从前往后判断。如果此时low指针指向的元素小于nums[high]，则low指针继续右移。若nums[low]大于nums[high],则把nums[low]赋给nums[high],即nuns[high]=nums[low]，赋值操作low不用右移。
然后再开始从前往后遍历,直到low=high结束循环,此时low或high的下标就是基准数据23在该数组中的正确索引位置.
这样一遍走下来,可以很清楚的知道,其实快速排序的本质就是把基准数大的都放在基准数的右边,把比基准数小的放在基准数的左边,这样就找到了该数据在数组中的正确位置.
以后采用递归的方式分别对前半部分和后半部分排序，当前半部分和后半部分均有序时该数组就自然有序了。
堆
用于求解 TopK Elements 问题，也就是 K 个最小元素的问题。可以维护一个大小为 K 的最小堆，最小堆中的元素就是最小元素。最小堆需要使用大顶堆来实现，大顶堆表示堆顶元素是堆中最大元素。这是因为我们要得到 k 个最小的元素，因此当遍历到一个新的元素时，需要知道这个新元素是否比堆中最大的元素更小，更小的话就把堆中最大元素去除，并将新元素添加到堆中。所以我们需要很容易得到最大元素并移除最大元素，大顶堆就能很好满足这个要求。
堆也可以用于求解 Kth Element 问题，得到了大小为 k 的最小堆之后，因为使用了大顶堆来实现，因此堆顶元素就是第 k 大的元素。
快速选择也可以求解 TopK Elements 问题，因为找到 Kth Element 之后，再遍历一次数组，所有小于等于 Kth Element 的元素都是 TopK Elements。
可以看到，快速选择和堆排序都可以求解 Kth Element 和 TopK Elements 问题。
做过的一个 优先队列题378和一个我以为用优先队列但不是的题（？）。。。（复习一下）
1. Kth Element
215. Kth Largest Element in an Array (Medium)
在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
Input: [3,2,1,5,6,4] and k = 2
Output: 5
题目描述：找到倒数第 k 个的元素。
378题是第k小，这里是找第k大。。也可以用最大优先队列自动排序
方法一：堆排序
class Solution { public int findKthLargest(int[] nums, int k) { PriorityQueue<Integer> MaxPQ = new PriorityQueue<>(Collections.reverseOrder()); for(int num:nums){ MaxPQ.add(num);//先全给他加进去会自动排序 最大的在外面 } for(int i = 1;i<k;i++){//把第k个前面的全出了 MaxPQ.remove(); } return MaxPQ.remove();//第k个就找到了 } }
这里用最大优先队列，把比k位小的们都放在队列里，大的出掉了。
若改成用最小优先队列（最小堆），则应该是放入的是比k位大的们，则堆顶是最小的k位了。
看答案也太。。。Arrays.sort()用一下就出来。。。（JDK默认使用快速排序）
方法二：排序
public int findKthLargest(int[] nums, int k) { int len = nums.length; Arrays.sort(nums); return nums[len - k]; }
方法三：自己用代码实现快速排序的分治
借助 partition 操作定位到最终排定以后索引为 len - k 的那个元素（特别注意：随机化切分元素）
以下的描述基于 “快速排序” 算法知识的学习，如果忘记的朋友们可以翻一翻自己的《数据结构与算法》教材，复习一下，partition 过程、分治思想和 “快速排序” 算法的优化。
分析：我们在学习 “快速排序” 的时候，接触的第 1 个操作就是 partition（切分），简单介绍如下：
其中 partition 分区函数会任意选择一个元素作为 pivot（分区点），将数组中小于 pivot 的点都放置到其左边，将大于pivot的点都放置在其右边，最终 partition 函数返回 pivot 的下标 i
partition（切分）操作，使得：
对于某个索引 j，nums[j] 已经排定，即 nums[j] 经过 partition（切分）操作以后会放置在它 “最终应该放置的地方”；
nums[left] 到 nums[j - 1] 中的所有元素都不大于 nums[j]；
nums[j + 1] 到 nums[right] 中的所有元素都不小于 nums[j]。
partition（切分）操作总能排定一个元素，还能够知道这个元素它最终所在的位置，这样每经过一次 partition（切分）操作就能缩小搜索的范围，这样的思想叫做 “减而治之”（是 “分而治之” 思想的特例）。
切分过程可以不借助额外的数组空间，仅通过交换数组元素实现。
顺便回忆一下”快排“的实现
quick_sort(int[] arr, int low, int high) { if (low >= high) return; int i = partition(arr, low, high);//返回pivot的正确索引值 quick_sort(arr, low, i-1); quick_sort(arr, i+1, high); }
该题答案：
class Solution { //比较j与处理后的k（正序），分割知道j==k public int findKthLargest(int[] nums, int k) { k = nums.length - k; int l = 0, h = nums.length - 1; while (l < h) { int j = partition(nums, l, h);//得到pivot的正确索引值 if (j == k) { break; } else if (j < k) { l = j + 1;//选后半段 } else { h = j - 1;//选前半段 } } return nums[k]; } //在l~h范围内分割，找到位置为j的数 有点没看懂。。。 private int partition(int[] a, int l, int h) { int i = l, j = h + 1; while (true) { while (a[++i] < a[l] && i < h) ;//这里是啥？？？？？交换还是just指针动？ while (a[--j] > a[l] && j > l) ; if (i >= j) { break; } swap(a, i, j);//??? } swap(a, l, j);//???? return j; } //交换a[i]与a[j] private void swap(int[] a, int i, int j) { int t = a[i]; a[i] = a[j]; a[j] = t; } }
没看懂。。。。？？？
桶排序
1. 出现频率最多的 k 个元素
Leetcode题号：347 难度：Medium
链接：https://leetcode-cn.com/problems/top-k-frequent-elements/description/
题目描述：
给定一个非空的整数数组，返回其中出现频率前 k 高的元素。
写半天结果还是错的。。。就悟出了一个数组中加元素的道理
数组的初始化 你可以在声明数组的同时进行初始化（静态初始化）， 也可以在声明以后进行初始化（动态初始化）。例如： // 静态初始化 // 静态初始化的同时就为数组元素分配空间并赋值 int intArray[] = {1,2,3,4}; String stringArray[] = {"微学苑", "http://www.weixueyuan.net", "一切编程语言都是纸老虎"}; // 动态初始化 float floatArray[] = new float[3]; floatArray[0] = 1.0f; floatArray[1] = 132.63f; floatArray[2] = 100F;
题目答案：
整道题思路可以分为3步：
1.将数组中的数按照 数字--出现频数 的格式存放在一个HashMap中。
2.将该HashMap中的内容放入一组桶中，其中，这组桶代表一个大ArrayList（第一次见这操作！）。这组桶的每一个元素都是一个桶（每个桶都是一个ArrayList），它的下标（索引）表示频数。每个桶都存放着对应该频数的数字。若同一频数的数字有多个，那么对应的桶中就会有多个数。
3.最后，从索引最大的桶开始，取出频数最大的k个数字即可。
上面是map 下面是桶，桶都是几到几一组的，比如这里是频率1到5的桶都有
注意其中用到的一些方法：
HashMap的getOrDefault（key，default）表示如果存在key对应的value，就返回该value，若不存在该key，就返回default位置的值。
ArrayList的addAll（）方法表示括号里的所有元素都添加到ArrayList中。
class Solution { public List<Integer> topKFrequent(int[] nums, int k) { //存放 数字-数字对应的频数 Map<Integer,Integer> f = new HashMap<>(); for (int num : nums) { f.put(num, f.getOrDefault(num, 0) + 1); } //桶：桶的索引表示频数，每个索引位置放入对应频数的数字 List<Integer>[] buckets = new ArrayList[nums.length + 1];//因为下标设置成了从1开始？可是长度为啥加1？？ for (int key : f.keySet()) { int frequency = f.get(key);//把map的计数值们都取出赋给了桶的索引值 if (buckets[frequency] == null) { //因为可能存在频数相同的数字，因此每个索引位置都是一个数组 buckets[frequency] = new ArrayList<>();//桶的索引对应的值们存在arraylist里面 } //根据桶的索引（频数），放入对应的数字（key） buckets[frequency].add(key);//这个arraylist里面是map的key即输入数组元素值 } List <Integer> topK = new ArrayList<>(); //从桶的最后一个元素开始遍历，往topK数组里面放频率最大的数，放满k个停止 for (int i = buckets.length - 1; i >= 0 && topK.size() < k; i--) { //如果频率i没有对应的数，就跳过找下一个频率 if (buckets[i] == null) { continue; } //当前频率的数的个数小于k，就将这些数全部放入topK if (buckets[i].size() <= (k - topK.size())) { topK.addAll(buckets[i]); } else { //topK还剩几个位子，就放几个数 topK.addAll(buckets[i].subList(0, k - topK.size())); } } return topK; } }
可是leetcode上返回的是int,需要转换一下，就是按索引遍历给数组一个一个加元素。
public int[] topKFrequent(int[] nums, int k) { Map<Integer,Integer> map = new HashMap<>(); for(int num:nums){ map.put(num,map.getOrDefault(num,0)+1); } //桶排序 //将频率作为数组下标，对于出现频率不同的数字集合，存入对应的数组下标 List<Integer>[] list = new List[nums.length+1];//new一组桶List for(int key : map.keySet()){ // 获取出现的次数作为下标 int i = map.get(key); if(list[i] == null){ list[i] = new ArrayList();//每个索引对应的还是list } list[i].add(key); } // 倒序遍历数组获取出现顺序从大到小的排列 List<Integer> res = new ArrayList(); for(int i = list.length - 1;i >= 0 && res.size() < k;i--){ if(list[i] == null) continue; res.addAll(list[i]); } int[] listt = new int[res.size()]; int idx=0; for(int num:res){ listt[idx++]= num; } return listt; }
2. 按照字符出现次数对字符串排序
451. Sort Characters By Frequency (Medium)
给定一个字符串，请将字符串里的字符按照出现的频率降序排列。
示例 1:
输入:
"tree"
输出:
"eert"
解释:
'e'出现两次，'r'和't'都只出现一次。
因此'e'必须出现在'r'和't'之前。此外，"eetr"也是一个有效的答案。
class Solution { public String frequencySort(String s) { Map<Character,Integer> map = new HashMap<>(); //遍历String for (char c : s.toCharArray()){ map.put(c, map.getOrDefault(c, 0) + 1); } List<Character>[] Bucket = new List[s.length()+1];//又是长度要加1 是个List们的数组们 for(char c:map.keySet()){ int f = map.get(c);//索引放入计数 if(Bucket[f] == null){ Bucket[f] = new ArrayList<>(); } Bucket[f].add(c); } //从桶中索引最大的元素开始，依次取出字母放入可变字符串str中 StringBuilder str = new StringBuilder(); for (int i = Bucket.length - 1; i >= 0; i--) { if (Bucket[i] == null) { continue; } for (char c : Bucket[i]) { for (int j = 0; j < i; j++) { str.append(c); } } } return str.toString(); } }
荷兰国旗问题
荷兰国旗包含三种颜色：红、白、蓝。
有三种颜色的球，算法的目标是将这三种球按颜色顺序正确地排列。它其实是三向切分快速排序的一种变种，在三向切分快速排序中，每次切分都将数组分成三个区间：小于切分元素、等于切分元素、大于切分元素，而该算法是将数组分成三个区间：等于红色、等于白色、等于蓝色。
1. 按颜色进行排序
75. Sort Colors (Medium)
Input: [2,0,2,1,1,0]
Output: [0,0,1,1,2,2]
给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。
此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。
注意:
不能使用代码库中的排序函数来解决这道题。
示例:
输入: [2,0,2,1,1,0]
输出: [0,0,1,1,2,2]
答案：
1、len 是数组的长度；
2、变量 zero 是前两个子区间的分界点，一个是闭区间，另一个就必须是开区间；
3、变量 i 是循环变量，一般设置为开区间，表示 i 之前的元素是遍历过的；
4、two 是另一个分界线，我设计成闭区间。
public class Solution { public void sortColors(int[] nums) { int len = nums.length; if (len < 2) { return; } // all in [0, zero) = 0 // all in [zero, i) = 1 // all in [two, len - 1] = 2 // 循环终止条件是 i == two，那么循环可以继续的条件是 i < two // 为了保证初始化的时候 [0, zero) 为空，设置 zero = 0， // 所以下面遍历到 0 的时候，先交换，再加 int zero = 0;//占着最前面 // 为了保证初始化的时候 [two, len - 1] 为空，设置 two = len // 所以下面遍历到 2 的时候，先减，再交换 int two = len-1;//占着最后面 int i = 0; // 当 i == two 上面的三个子区间正好覆盖了全部数组 // 因此，循环可以继续的条件是 i <= two while (i < =two) {//有点分治那意思，小的换前面去，大的换后面去 if (nums[i] == 0) { swap(nums, i, zero);// i遇到0 把0换前面去。值交换，索引没有换，向右推1步 zero++; i++; } else if (nums[i] == 1) { i++;//不管 } else {//i遇到2 把2换后面去 swap(nums, i, two);
two--;
} } } private void swap(int[] nums, int index1, int index2) {//传入的索引指针 int temp = nums[index1]; nums[index1] = nums[index2]; nums[index2] = temp; } } 作者：liweiwei1419 链接：https://leetcode-cn.com/problems/sort-colors/solution/kuai-su-pai-xu-partition-guo-cheng-she-ji-xun-huan/ 来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。