堆排序

堆排序

 

二叉堆的定义

二叉堆满足二个特性：

1．父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值。

2．每个结点的左子树和右子树都是一个二叉堆（都是最大堆或最小堆）。

当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆。

基本思想

             把每个叶子节点看作是一个堆，并从最后一个非叶子节点开始调整，保证以当前节点为根的子树被调整为堆，直至根节点即可。

建堆复杂度分析

           建堆复杂度是O(n)，整体复杂度是O(nlogn)。

        构建堆从叶节点的父节点开始，以树高递减的方向逐层往上，一直到根。

        假设堆中共有N个元素，则树高H=log2(N)，对于从树高为h的节点建堆的复杂度为O(H - h)；

        从最底层开始，为从各节点建堆的复杂度求和：

        S = 1 * 2^(H-1) + 2 * 2^(H-2) + ... + (H-1) * 2^1 + H * 2^0

        = 2^H + 2^(H-1) + ... + 2^1 - H

        = 2^(H+1) - 2 - H

        将H=log2(N)代入，S = 2N - 2 - log2(N)

源代码

void myswap(int &a, int &b)
{
	int tmp = a;
	a = b;
	b = tmp;
}


//push element i down to a proper layer
//until the subtree rooted by i is adjusted to a heap
void minHeapFixdown(int heap[], int i, int n)
{
	int tmp = heap[i];
	int j = 2*i + 1;
	while(j < n)
	{
		if((j+1 < n) && heap[j+1] < heap[j])
			j++;
		if(tmp <= heap[j])
			break;
		heap[i] = heap[j];
		i = j;
		j = 2*i + 1;
	}
	heap[i]  = tmp;
}

//adjust the original array to a minheap
//fix the nodes down from the last midnode to the root node
void adjustMinHeap(int heap[],int n)
{
	for(int i = (n-1 -1)/2; i >= 0; i--)
		minHeapFixdown(heap,i,n);
}

//drop the top element to the last slot indexed as ind
//and maintain the array as minheap 
void dropElement(int heap[], int ind)
{
	myswap(heap[0], heap[ind]);
	minHeapFixdown(heap, 0, ind);
}

//iteratively drop the top element to the last available slot
void minHeapSort(int heap[], int n)
{
	adjustMinHeap(heap, n);
	for(int ind = n-1; ind >= 0; ind--)
	{
		dropElement(heap,ind);
	}
}

//fix the bottom element up to a proper layer
//require that the array is already adjusted as a minheap
void minHeapFixup(int heap[], int ind)
{
	int p = (ind-1)/2;
	int tmp = heap[ind];
	while(p >= 0)
	{
		if(heap[ind] >= heap[p])
			break;
		heap[ind] = heap[p];
		ind = p;
		p = (ind-1)/2;
	}
	heap[ind] = tmp;
}

//add a new value to the last slot not used as the bottom of the heap
//and fix it up
void addElement(int heap[], int ind, int value)
{
	heap[ind] = value;
	minHeapFixup(heap, ind);
}

int main(void)
{
	int heap[8] = {8,4,7,6,2};
	adjustMinHeap(heap, 5);
	addElement(heap, 5, 3);
	minHeapSort(heap, 6);
	
	for(int i = 0; i < 6; i++)
		cout<<heap[i]<<" "<<endl;
	cout<<endl;
	return 0;
}