左神堆排序超详解

堆排序基础

• 堆是具有下列性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。
  
  左图是个大根堆，根结点是所有元素中最大的，右图是个小根堆，根结点是所有元素中最小的。

• 如果将这个完全二叉树中的数字，从0开始全部依次排入到数组中，则他的跟结点和左右孩子满足以下关系：
  

• 堆排序的基本思想是，将待排序的序列构成一个大顶堆。此时，整个序列的最大值就是堆顶的根结点。将它移走（其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值），然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素中的次小值。如此反复进行，便能得到一个有序的序列。

堆调整过程

向上查找

• 假设我们一有个一定长度的一维数组，我们每次往数组中添加一个数字，那么添加的数字个数就是该数组的有效长度。在添加的过程中我们模拟堆排序的过程，假设构造一个大顶堆：
  
  （用鼠标画的图，太丑啦，凑合看叭,ԾㅂԾ,）

以下给出插入堆的代码：（heapInsert）

1. arr[0…index-1]已经是大根堆，某个数据现在处于index位置，往上继续移动
2. 希望经过调整arr[0…index] 都是大根堆

void heapInsert(int arr[],int index)
{
	//两个判断条件：
	//1.左孩子或右孩子大于跟结点
	//2.左孩子或右孩子和跟结点相等——到达根部
	while(arr[index]>arr[(index-1)/2])
	{
		swap(arr,index,(index-1)/2); //交换
		index=(index-1)/2;
	}
}

每在堆中加入一个数字，就要 O(logn)，因为完全二叉树中，在第n个结点的深度是log(2,n)，加入n个数字时间复杂度就是O(n*logn)

向下查找（下沉）

• 在完成上述操作之后，再将这个堆中最大的元素进行 pop(max) 操作，也就是将最大元素弹出后，使新的堆仍然是一个大顶堆。如下给出操作过程：
  
  以下给出堆调整代码：（heapify）

//某个数在index位置，看看能否往下沉
//不断和左右两个孩子比较
//较大的孩子如果大于当前的父节点
//父节点下沉，较大的孩子上来，周而复始
void heapify(itn arr[],int index,int heapSize)
{
	int left=index*2+1;  //左孩子的下标
	while(left<heapSize)  //直到下标不能再增加
	{
		//两个孩子谁大 就让谁交换
		//left+1是右孩子下标，如果右孩子越界，就把左孩子下标给largest
		int largest=
		    left+1<heapSize&&arr[left+1]>arr[left]
		    ?left+1:left;
		//父和较大孩子之间，谁的值大，把下标给largest
		largest=arr[index]>arr[largest]?index:largest;
		
		if(largest==index) //当前结点的值就是最大的
		{
			break;
		}
		swap(arr,largest,index);
	index=largest;
	left=index*2+1;
	} 
}

扩容情况下的时间复杂度分析

如果数组的长度不够，那就需要再建立一个数组，是这个数组长度的2倍，那么将原来的n个元素再移到新数组中，时间复杂度为O(n)，这是单次扩容的代价。
假设刚开始的数组长度为1，经过扩容长度变为2，再次扩容变成4，再扩变成8。如果有1000个数字，需要扩log(2,1000)次，则n个元素扩容的时间复杂度为 扩容的次数 X 单次扩容的代价，即 log(2,n)*O(n)。所以扩容n次的平均代价，再除以N，平均时间复杂度依然是 O(log(2,n))。

堆排序

• 当构建好一个大根堆之后，把最顶端的数字和最后一个数字交换，然后将有效长度减少1，使顶端的数字和这个数组断连，再次调整堆的顺序，使它又成为一个大根堆，再将跟结点与当前数组的最后一个数字交换位置，再将其断连，重复上述过程，进行n次操作后，就将数组从小到大排好了。
  
  以下给出堆排序的代码：（heapSort）

void heapSort(int arr[])
{
	if(arr==NULL||arr.length<2){
		return ;
	}
	//O(N*logN)
	//一个一个往数组中添加数字
	for(int i=0;i<arr.length;i++)//O(N)
		heapInsert(arr,i);  //O(logN)
	//O(N*logN)
	int heapSize=arr.length;
	swap(arr,0,--heapSize);
	while(heapSize>0)   //O(N)
	{
		heapify(arr,0,heapSize);//O(logN)
		swap(arr,0,--heapSize); //O(1)
	} 	
}

注意： 这是用户一个一个的往数组中添加数字，然后每添加一次，就进行一次堆调整。这和直接给定一个数组，然后对这个数组进行堆排序是不同的，这种情况只需要从倒数第二层开始往上考虑，因为给定数组其实就是给定了完全二叉树，那么最后一层上的结点，已经自身满足了大根堆的条件。第二种方式，比第一种方式快，以下给出一个证明。

————最后得出它的时间复杂度为O(N)。

void heapSort(int arr[])
{
	if(arr==NULL||arr.length<2){
		return ;
	}
	//O(N)
	//直接将数组变成大根堆
	for(int i=arr.length-1;i>=0;i--){
		heapify(arr,i,arr.length);
		}
		//O(N*logN)
	int heapSize=arr.length;
	swap(arr,0,--heapSize);
	while(heapSize>0)   //O(N)
	{
		heapify(arr,0,heapSize);//O(logN)
		swap(arr,0,--heapSize); //O(1)
	} 	
}

————让 i 从 arr.length/2位置开始调整更

使用系统提供的堆排序

• C++中的优先队列 priority_queue

#include<iostream>
#include<queue>
using namespace std;
int main()
{
	priority_queue<int>heap;
	heap.push(10);
	heap.push(8);
	heap.push(9);
	heap.push(12);
	heap.push(3);

	while(heap.size()>0)
	{
		cout<<heap.top()<<" ";
		heap.pop();
	}
	return 0;
}

ACM例题：搬石子

堆排序扩展问题

• 已知一个几乎有序的数组，几乎有序是指，如果把数组排好序的话，每个元素移动的距离可以不超过k，并且k相对于数组来说比较小。请选择一个合适的排序算法针对这个数据进行排序。

分析： 假设k的值等于7，那么我们申请一个可以容纳8个数的小根堆。将数组下标从0到7的数字放入小根堆中。接着从这个小根堆中弹出一个数，那么这么数就是该数组最小的数，然后再向着个堆中添加一个数，再弹出……这样可以确保每个数字移动的距离不超过7。因为一个容量为8的小顶堆，最后一位移动到第一位最多只需要7次。如下图所示：