Analysis and implement some simple sorting algorithm.(2)——heapsort

//modified by quanspace 2013-02-19 20:16

//the time complexity is O(nlgn).
# include <iostream>
# include <cmath>
using namespace std;
class heapsort{
        public:
		void print_heap(int a[], int a_size);
		void max_heapify(int a[], int root, int a_size);
		void build_max_heap(int a[], int a_size);
		void int_heapsort(int a[], int a_size);
	private:
		int *heap;
		int heap_size;
};
void heapsort::print_heap(int a[], int a_size){
	heap = a;  heap_size = a_size;
	for(int i = 0; i != heap_size; ++i){
		cout<<*(heap+i)<<" ";
	}
	cout<<endl;
}

//max_heapify is maintain the heap(big root) property.
void heapsort::max_heapify(int a[],int root, int a_size){
	int left_child = 2*root;
	int right_child = 2*root+1;
	int max = 0;
	if(left_child<=a_size-1 && a[left_child]>a[root])
		max = left_child;
	else
		max = root;
	if(right_child<=a_size-1 && a[right_child]>a[max])
		max = right_child;
	if(max != root){
		int temp = a[root];
		a[root] = a[max];
		a[max] = temp;
		max_heapify(a, max, a_size);
	}
}

void heapsort::build_max_heap(int a[], int a_size){
	heap_size = a_size;

        //regardless of the leaves node of tree.

	for(int i = floor((heap_size-1)/2); i>=0; --i){
		max_heapify(a, i, heap_size);
	}
}

void heapsort::int_heapsort(int a[], int a_size){
	heap_size = a_size;
	build_max_heap(a, heap_size);
	for(int i = heap_size-1; i>=1; --i){
		int temp = a[i];
		a[i] = a[0];
		a[0] = temp;
		heap_size = heap_size-1;
		max_heapify(a,0,heap_size);
	}
}
int main(){
	const int arr_size = 10;
	int a[arr_size] = {4, 1, 3, 2, 16, 9, 8, 14, 10, 7};
	heapsort hs;
	cout<<"The original heap is: ";
	hs.print_heap(a, arr_size);
	hs.int_heapsort(a, arr_size);
	cout<<"After heap-sort: ";
	hs.print_heap(a, arr_size);
	return 0;
}