堆排序

排序算法之堆排序

1.      堆

堆一般指二叉堆，是一颗完全二叉树，可以很方便的用数组存储数据，其父节点和子节点满足如下关系：parent(i)= i/2; leftchild(i) = 2*I; rightchild = 2*i+1。

再用数组存储时注意，数组小标从1开始。

最大堆：父节点的值大于子节点的值。

最小堆：父节点的值小于子节点的值。

几个时间复杂度：保持堆性质的操作：O(lgn);

                                   建立最大堆的操作：O(n);

                                   堆排序                      ：O(nlgn);

                                   插入操作，删除操作：O(lgn)。

2.      保持堆的性质

堆与堆中的某一个节点A[i]，它的左子树和右子树均满足堆的性质（最大堆、最小堆），该操作就是要将A[i]为根节点的子树进行堆化。MAX_HEAPIFY(A,i)让A[i]在最大堆中下降：下列伪代码来自算法导论P75：

MAX_HEAPIFY(A,i)
        l = left(i)
        r = right(i)
        if l <= heap_size[A] and A[l]>A[i]
                largest = l
         else
             largest = i
         if r <= heap_size[A] and A[r]>A[largest]
               largest = r
         if largest != i
             exchange(A[i],A[largest])           //与最大值互换位置，递归堆化子树
             MAX_HEAPIFY(A,largest)

复杂度是O(lgn)或者O(h)，h为节点的高度。

3.      建立堆

对于一棵树而言，叶子节点本身就满足堆的性质，所以只需要堆化树中的非叶子节点即可，对于完全二叉树：我们假设a = 有2个孩子的节点，b = 有1个孩子的节点，c = 没有孩子的节点，则n = a+b+c，显然a = c-1，则n+1=2*c+b,又因为当n+1为偶数时，b=0，当n+1为奇数时，b=1，所以c = （n+1）/2。即一颗完全二叉树中，叶子数为（n+1）/2，所以在数组中，我们只需要将非叶子节点最大化即可，编号从1到n/2，但是堆化的过程肯定是由下往上的。伪代码如下：

BUILD_MAX_HEAPUFY(A)
               heap_size[A] = length[A]
                for i = length[A]/2 to 1
                               do MAX_HEAPIFY(A,i)

堆化时间复杂度是O(lgn),建立堆的时间复杂度是O(n)。

4.      堆排序

有了堆化函数和建立堆的函数，可以每次通过将最大元素和堆的最后一个元素互换，再将堆最大化的递归过程排序，伪代码如下：

HEAPSORT(A)
               BUILD_MAX_HEAP(A)
                for i = length[A] to 2
                               do exchange(A[i],A[1])
                                             heap_siez[A] -= 1
                                             MAX_HEAPIFY(A,1)

5.      C++实现代码

#include <iostream>
#include <fstream>
using namespace std;
#define max_size 1000

int data[max_size];
int data_size;

inline void swap(int *a,int *b)
{
	int c;
	c = *a;
	*a = *b;
	*b = c;
}

void max_heapify(int i);
void buil_max_heap();
void heap_sort();

int main()
{
	ifstream instream;
	instream.open("data.txt");
	int i;
	for( i =1;(!instream.eof())&&((instream>>data[i]))&&i<max_size;i++)
	{}
	data_size = i-1;
	heap_sort();
	for(int j=1;j<i;j++)
		cout<<data[j]<<endl;
}

void max_heapify(int i)
{
	int left = 2*i;
	int right = 2*i+1;
	int largest = i;
	if(left <= data_size && data[left]>data[i])
		largest = left;
	if(right <=data_size && data[right]>data[largest])
		largest = right;
	if(largest != i)
	{
		swap(&data[i],&data[largest]);
		max_heapify(largest);
	}
}

void buil_max_heap()
{
	for(int i = data_size/2;i>=1;i--)
		max_heapify(i);
}

void heap_sort()
{
	buil_max_heap();
	for(int i = data_size;i>=2;i--)
	{
		swap(data[i],data[1]);
		data_size--;
		max_heapify(1);
	}
}