Java 大顶堆 PriorityQueue 堆排序大顶堆

堆数据结构实际上是一种数组对象，是以数组的形式存储的，可是它能够被视为一颗全然二叉树，因此又叫二叉堆。堆分为下面两种类型：

大顶堆：父结点的值不小于其子结点的值，堆顶元素最大

小顶堆：父结点的值不大于其子结点的值，堆顶元素最小

堆排序的时间复杂度跟合并排序一样，都是O(nlgn)，可是合并排序不是原地排序（原地排序：在排序过程中，仅仅有常数个元素是保存在数组以外的空间），合并排序的全部元素都被复制到另外的数组空间中去，而堆排序是一个原地排序算法。

1、在堆排序中，我们通常使用大顶堆来实现，因为堆在操作上是被看着一颗全然二叉树，所以其高度为lgn，堆结构上的一些操作的时间复杂度也一般是O(lgn)。

/*
 *	算法导论 第六章 堆排序
 *	堆数据结构的实际存储是作为一个顺序数组来保存的
 *	对堆的操作是将它作为一个全然二叉树的结构来使用的
 *	
 *	堆排序也是属于一种选择排序，只是相比简单选择排序（时间复杂度为O(n^2)），堆排序要快得多
 *	堆排序分为下面几个步骤：
 *	首先是建立大顶堆，即函数buildMaxHeap，建堆实际上是利用堆的最大化调整(maxHeapify)自底向上来实现的
 *	然后是逐步将堆顶的最大元素交换到堆的结尾，堆的大小也不断缩小，然后再将堆最大化，从而实现排序
 *	
 *	当中建堆的时间复杂度为O(n)，堆的最大化调整时间复杂度为O(lgn)，所以总的
 *	时间复杂度是O(n*lgn+n)，即O(nlgn)
 */
#include <iostream>
using namespace std;

void printArray(int arr[], int len);
void heapSort(int arr[], int len);
void maxHeapify(int arr[], int heapSize, int pos);
void buildMaxHeap(int arr[], int len);
void selectSort(int *arr, int len);
void exchange(int arr[], int i, int j);

int main()
{
	int arr[] = {16, 14, 10, 8, 7, 9, 3, 2, 4, 1};
	int len = sizeof(arr) / sizeof(arr[0]);

	cout << "原数组：" << endl;
	printArray(arr, len);

	heapSort(arr, len);
	//selectSort(arr, len);

	cout << "排序后的数组：" << endl;
	printArray(arr, len);

	return 0;
}

void printArray(int arr[], int len)
{
	for (int i=0; i<len; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}

void heapSort(int arr[], int len)
{
	buildMaxHeap(arr, len);
	for (int i=len-1; i>0; i--)
	{
		int temp = arr[0];
		arr[0] = arr[i];
		arr[i] = temp;
		maxHeapify(arr, i, 0);
	}
}

void maxHeapify(int arr[], int heapSize, int pos)
{
	int lPos = (pos + 1) * 2 - 1;
	int rPos = (pos + 1) * 2;
	int largest = pos;
	if (lPos < heapSize && arr[lPos] > arr[largest])
		largest = lPos;
	if (rPos < heapSize && arr[rPos] > arr[largest])
		largest = rPos;

	if (largest != pos)
	{
		int temp = arr[pos];
		arr[pos] = arr[largest];
		arr[largest] = temp;
		maxHeapify(arr, heapSize, largest);
	}
}

void buildMaxHeap(int arr[], int len)
{
	for (int i=len/2-1; i>=0; i--)
	{
		maxHeapify(arr, len, i);
	}
}

/*
 *	简单选择排序
 *	每次经过 n-i 次比較，从序列中选出i之后的最小元素放在第 i 个位置，以此排序
 *	时间复杂度为O(n^2)
 */
void selectSort(int *arr, int len)
{
	for (int i=0; i<len; i++)
	{
		int minIndex = i;
		for (int j=i+1; j<len; j++)
		{
			if (arr[j] < arr[minIndex])
				minIndex = j;
		}
		if (minIndex != i)
		{
			exchange(arr, i, minIndex);
		}
	}
}

void exchange(int arr[], int i, int j)
{
	int temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
}

2、堆结构能够用来实现优先级队列，优先级队列是一组元素构成的集合，能够从中取出最大或者最小的元素，堆是优先级队列的一种非常好的实现。通过堆，优先级队列上的随意操作能够再O(lgn)时间内实现。

3、习题6.5-8解答

/*
 *	算法导论 第六章 习题6.5-8
 *	
 *	将k个链表中的首元素取出来作为一个数组，构成一个最小堆，堆顶元素即为最小
 *	每次将堆顶元素插入到新链表尾部，然后将该元素原来所在链表的下一元素取出放到堆顶
 *	若该链表取完了，则直接将堆尾元素放到堆顶，并将堆的大小减1，调整堆，反复取出堆顶
 *	最小元素插入到新链表，直到k个链表都为空了为止
 *	
 *	时间复杂度分析：建堆为O(k)，取出堆中最小元素为O(lgk)，共取了n次
 *	时间复杂度为O(k+nlgk)=O(nlgk)
 */

#include <iostream>
using namespace std;

typedef struct LinkNode 
{
	int key;
	LinkNode *next;
} LinkNode;

LinkNode* createLink(int arr[], int len);
LinkNode* heapExtractMin(LinkNode* arr[], int &len);
void minHeapify(LinkNode* arr[], int heapSize, int pos);
void buildMinHeap(LinkNode* arr[], int len);

int main()
{
	int k = 5, n = 20;

	int arr1[3] = {11, 14, 67};
	int arr2[2] = {5, 35};
	int arr3[5] = {3, 8, 12, 25, 90};
	int arr4[4] = {9, 21, 49, 73};
	int arr5[6] = {1, 32, 33, 45, 53, 88};

	LinkNode *link1 = createLink(arr1, 3);
	LinkNode *link2 = createLink(arr2, 2);
	LinkNode *link3 = createLink(arr3, 5);
	LinkNode *link4 = createLink(arr4, 4);
	LinkNode *link5 = createLink(arr5, 6);

	/*
	 *	把堆定义成一个指针数组，须要注意指针数组与数组指针的差别
	 *	指针数组：定义的是一个数组，数组中的每个元素都是一个指针
	 *	数组指针：定义的是一个指针，这个指针指向一个数组
	 */
	//定义堆数组
	LinkNode* heap[] = {link1, link2, link3, link4, link5};

	buildMinHeap(heap, k);

	//定义又一次排序后的链表
	LinkNode *resultLink = heapExtractMin(heap, k);
	LinkNode *beforeNode = resultLink;
	while (beforeNode && n-- > 1)
	{
		LinkNode *node = heapExtractMin(heap, k);
		beforeNode->next = node;
		beforeNode = node;
	}

	while (resultLink)
	{
		cout << resultLink->key << " ";
		LinkNode *node = resultLink;
		resultLink = resultLink->next;
		delete node;
	}
	cout << endl;

	return 0;
}

LinkNode* createLink(int arr[], int len)
{
	LinkNode *nextNode = NULL;
	for (int i=len-1; i>=0; i--)
	{
		LinkNode *node = new LinkNode();
		node->key = arr[i];
		node->next = nextNode;
		nextNode = node;
	}
	return nextNode;
}

LinkNode* heapExtractMin(LinkNode* arr[], int &len)
{
	if (len < 1)
		return NULL;
	LinkNode *minNode = arr[0];
	if (arr[0]->next)
	{
		arr[0] = arr[0]->next;
	} else {
		len--;
		arr[0] = arr[len];
	}
	if (len > 1)
	{
		minHeapify(arr, len, 0);
	}

	return minNode;
}

void minHeapify(LinkNode* arr[], int heapSize, int pos)
{
	int lPos = (pos + 1) * 2 - 1;
	int rPos = (pos + 1) * 2;
	int smallest = pos;
	if (lPos < heapSize && arr[lPos]->key < arr[smallest]->key)
		smallest = lPos;
	if (rPos < heapSize && arr[rPos]->key < arr[smallest]->key)
		smallest = rPos;

	if (smallest != pos)
	{
		LinkNode* temp = arr[pos];
		arr[pos] = arr[smallest];
		arr[smallest] = temp;
		minHeapify(arr, heapSize, smallest);
	}
}

void buildMinHeap(LinkNode* arr[], int len)
{
	for (int i=len/2-1; i>=0; i--)
	{
		minHeapify(arr, len, i);
	}
}