目录
1 堆排序
堆排序(Heap Sort)是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于(或者大于)它的父节点。
时间复杂度无论是最坏还是最好都是 ：O(nlgn) ,
但是它也是一种不稳定的算法，不适用于较小的数组 ，对于较大的文件比较有效
1.1什么是堆
堆是一个树形结构，其实堆的底层是一棵完全二叉树。而完全二叉树是一层一层按照进入的顺序排成的。按照这个特性，我们可以用数组来按照完全二叉树实现堆。
1.2 大顶堆与小顶堆
大顶堆原理：根结点（亦称为堆顶）的关键字是堆里所有结点关键字中最大者，称为大顶堆。大顶堆要求根节点的关键字既大于或等于左子树的关键字值，又大于或等于右子树的关键字值。
小顶堆原理：根结点（亦称为堆顶）的关键字是堆里所有结点关键字中最小者，称为小顶堆。小堆堆要求根节点的关键字既小于或等于左子树的关键字值，又小于或等于右子树的关键字值。
2 推排序思想
- 构建初始堆，将待排序列构成一个大顶堆(或者小顶堆)，升序大顶堆，降序小顶堆；
- 将堆顶元素与堆尾元素交换，并断开(从待排序列中移除)堆尾元素。
- 重新构建堆。
- 重复2~3，直到待排序列中只剩下一个元素(堆顶元素)。
2.1 图解
https://img2018.cnblogs.com/blog/1469176/201903/1469176-20190329000555410-1254067522.gif
2.2 代码实现
/**
* 堆排序演示
*
*/
public class HeapSort {
public static void main(String[] args) {
// int[] arr = {5, 1, 7, 3, 1, 6, 9, 4};
int[] arr = {16, 7, 3, 20, 17, 8};
heapSort(arr);
for (int i : arr) {
System.out.print(i + " ");
}
}
/**
* 创建堆，
* @param arr 待排序列
*/
private static void heapSort(int[] arr) {
//创建堆
for (int i = (arr.length - 1) / 2; i >= 0; i--) {
//从第一个非叶子结点从下至上，从右至左调整结构
adjustHeap(arr, i, arr.length);
}
//调整堆结构+交换堆顶元素与末尾元素
for (int i = arr.length - 1; i > 0; i--) {
//将堆顶元素与末尾元素进行交换
int temp = arr[i];
arr[i] = arr[0];
arr[0] = temp;
//重新对堆进行调整
adjustHeap(arr, 0, i);
}
}
/**
* 调整堆
* @param arr 待排序列
* @param parent 父节点
* @param length 待排序列尾元素索引
*/
private static void adjustHeap(int[] arr, int parent, int length) {
//将temp作为父节点
int temp = arr[parent];
//左孩子
int lChild = 2 * parent + 1;
while (lChild < length) {
//右孩子
int rChild = lChild + 1;
// 如果有右孩子结点，并且右孩子结点的值大于左孩子结点，则选取右孩子结点
if (rChild < length && arr[lChild] < arr[rChild]) {
lChild++;
}
// 如果父结点的值已经大于孩子结点的值，则直接结束
if (temp >= arr[lChild]) {
break;
}
// 把孩子结点的值赋给父结点
arr[parent] = arr[lChild];
//选取孩子结点的左孩子结点,继续向下筛选
parent = lChild;
lChild = 2 * lChild + 1;
}
arr[parent] = temp;
}
}3 java PriorityQueue
3.1总体介绍
PriorityQueue也叫优先队列，所谓优先队列指的就是每次从优先队列中取出来的元素要么是最大值（最大堆），要么是最小值（最小堆）。我们知道，队列是一种先进先出的数据结构，每次从队头出队（移走一个元素），从队尾插入一个元素（入队），可以类比生活中排队的例子就好理解了。
优先队列的作用是能保证每次取出的元素都是队列中权值最小的（Java的优先队列每次取最小元素，C++的优先队列每次取最大元素）。这里牵涉到了大小关系，元素大小的评判可以通过元素本身的自然顺序（natural ordering），也可以通过构造时传入的比较器（Comparator，类似于C++的仿函数）。
Java中PriorityQueue实现了Queue接口，不允许放入null元素；其通过堆实现，具体说是通过完全二叉树（complete binary tree）实现的小顶堆（任意一个非叶子节点的权值，都不大于其左右子节点的权值），也就意味着可以通过数组来作为PriorityQueue的底层实现。
上图中我们给每个元素按照层序遍历的方式进行了编号，如果你足够细心，会发现父节点和子节点的编号是有联系的，更确切的说父子节点的编号之间有如下关系：
leftNo = parentNo*2+1
rightNo = parentNo*2+2
parentNo = (nodeNo-1)/2
通过上述三个公式，可以轻易计算出某个节点的父节点以及子节点的下标。这也就是为什么可以直接用数组来存储堆的原因。
PriorityQueue的peek()和element操作是常数时间，add(), offer(), 无参数的remove()以及poll()方法的时间复杂度都是log(N)。
适合类型的堆来进行排序
升序----使用大顶堆
降序----使用小顶堆
3.2 方法剖析
add()和offer()
add(E e)和offer(E e)的语义相同，都是向优先队列中插入元素，只是Queue接口规定二者对插入失败时的处理不同，前者在插入失败时抛出异常，后则则会返回false。对于PriorityQueue这两个方法其实没什么差别。
新加入的元素x可能会破坏小顶堆的性质，因此需要进行调整。调整的过程为：从k指定的位置开始，将x逐层与当前点的parent进行比较并交换，直到满足x >= queue[parent]为止。注意这里的比较可以是元素的自然顺序，也可以是依靠比较器的顺序。
element()和peek()
element()和peek()的语义完全相同，都是获取但不删除队首元素，也就是队列中权值最小的那个元素，二者唯一的区别是当方法失败时前者抛出异常，后者返回null。根据小顶堆的性质，堆顶那个元素就是全局最小的那个；由于堆用数组表示，根据下标关系，0下标处的那个元素既是堆顶元素。所以直接返回数组0下标处的那个元素即可。
remove()和poll()
remove()和poll()方法的语义也完全相同，都是获取并删除队首元素，区别是当方法失败时前者抛出异常，后者返回null。由于删除操作会改变队列的结构，为维护小顶堆的性质，需要进行必要的调整
remove(Object o)
remove(Object o)方法用于删除队列中跟o相等的某一个元素（如果有多个相等，只删除一个），该方法不是Queue接口内的方法，而是Collection接口的方法。由于删除操作会改变队列结构，所以要进行调整；又由于删除元素的位置可能是任意的，所以调整过程比其它函数稍加繁琐。具体来说，remove(Object o)可以分为2种情况：1. 删除的是最后一个元素。直接删除即可，不需要调整。2. 删除的不是最后一个元素，从删除点开始以最后一个元素为参照调用一次siftDown()即可。此处不再赘述。
4 解决TopK问题
小顶堆
class KthLargest {
private PriorityQueue<Integer> priorityQueue;
//队列元素个数
int fix_k;
public KthLargest(int k, int[] nums) {
fix_k=k;
//堆队列保存k个有序数值，从小到大排列，首部小
priorityQueue=new PriorityQueue<>(k);
int n=nums.length;
//将数值添加到堆队列，超长只会保留k个比较大的元素
for (int x:nums)
{
add(x);
}
}
public int add(int val) {
int len=priorityQueue.size();
//如果队列长度没超，继续添加
if (len<fix_k)
{
priorityQueue.offer(val);
}else
{
//判断是否大于最小的队首元素
if (val>priorityQueue.peek())
{
priorityQueue.poll();
priorityQueue.offer(val);
}
}
//返回第k大元素
return priorityQueue.peek();
}
}215. 数组中的第K个最大元素//堆排序
Queue<Integer> queue=new PriorityQueue<>();
public int findKthLargest(int[] nums, int k) {
//数组遍历
for (int num:nums)
{
//如果堆队列小于k
if (queue.size()<k)
{
queue.add(num);
}else
{
//堆首元素小于num
if (queue.peek()<num)
{
queue.poll();
queue.add(num);
}
}
}
return queue.peek();
}
//快速排序
public int findKthLargest(int[] nums, int k)
{
quickSort(nums,0,nums.length-1,k-1);
return nums[k-1];
}
//快排
public void quickSort(int[] nums,int left,int right,int key)
{
if (left>right)
{
return;
}
int stand=partion(nums,left,right);
if (stand==key)
{
return;
}
else
{
quickSort(nums,left,stand-1,key);
quickSort(nums,stand+1,right,key);
}
}
//标准位寻找
public int partion(int[] nums,int left,int right)
{
int one=left;
int temp=nums[left];
//left
while (left<right)
{
while (left<right&&nums[right]<=temp)
{
right--;
}
while (left<right&&nums[left]>=temp)
{
left++;
}
if (left<right)
{
swap(nums,left,right);
}
}
//结束
swap(nums,one,left);
return left;
}
//交换
public void swap(int[] nums,int i,int j)
{
int temp=nums[i];
nums[i]=nums[j];
nums[j]=temp;
}
扫一扫
155
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
