[算法导论读书笔记]堆排序，优先队列

#include <stdio.h>
#include <time.h>
#include <algorithm>
#include <unistd.h>
//#include <string.h>
#include <stdlib.h>
#include <sys/times.h>
#define PARENT(i) (i/2)
#define LEFT(i) (2*i)
#define RIGHT(i) (2*i+1)
//test data
#define MAX 1000000

int HEAP_SIZE;
int ARR_LENGTH;
//keep max heap's attribulte
void MAX_HEAPIFY(int  *data, int i);
//build the max heap
void BUILD_MAX_HEAP(int *data);
//heap sort algorithm
void HEAPSORT( int *data);

void swap( int *data, int i, int j)
{
	int temp = data[i];
	data[i] = data[j];
	data[j] = temp;
}

int main(int argc, char* argv[])
{
	//data[0]不使用
	int data[MAX + 1];
	int i;
	int temp;
	int clock_per_sec = sysconf(_SC_CLK_TCK);
	long beg, end;
	struct tms begTms, endTms;
	srand(time(0));
	ARR_LENGTH = MAX;
	for( i = 1; i <= MAX; i++)
	{
		data[i] = rand() % MAX;
	}

	beg = times(&begTms);
	HEAPSORT(data);
	for( i = 1; i <= 10; i++)
	{
		printf("%d\t", data[i]);
	}
	end = times(&endTms);
	printf("\ntimes: %ld ms\n", (end-beg) * 1000 / clock_per_sec);

	beg = times(&begTms);
	std::sort(data+1, data+ARR_LENGTH + 1);
	for( i = 1; i <= 10; i++)
	{
		printf("%d\t", data[i]);
	}
	end = times(&endTms);
	printf("\ntimes: %ld ms\n", (end-beg) * 1000 / clock_per_sec);
}

void MAX_HEAPIFY(int  *data, int i)
{
	int l, r;
	int largest;
	l = LEFT(i);
	r = RIGHT(i);

	//compare its' left children and right children and it's seft
	//find the largest element
	if( l <= HEAP_SIZE && data[l] > data[i])
	{
		largest = l;
	}
	else
	{
		largest = i;
	}

	if( r <= HEAP_SIZE && data[r] > data[largest])
	{
		largest = r;
	}

	//if the largest is parent, then break
	//else, continue heapify.
	if( largest != i )
	{
		swap( data, i, largest);
		MAX_HEAPIFY(data, largest);
	}			
}
void BUILD_MAX_HEAP(int *data)
{
	int i;
	HEAP_SIZE = ARR_LENGTH;
	//Here, assume data[ n/2+1, n] which is leaf node meet max heap's need
	//then ,just adjust other element
	for( i = ARR_LENGTH / 2; i >= 1; i-- )
	{
		MAX_HEAPIFY(data, i);
	}
}
void HEAPSORT( int *data)
{
	int i;
	BUILD_MAX_HEAP(data);
	//extract the largest element from heap once per iterator
	//heap'size will decrease, and keep it's attribute
	for( i = ARR_LENGTH; i >= 2; i-- )
	{
		swap(data,1, i);
		HEAP_SIZE--;
		MAX_HEAPIFY(data, 1);
	}
}

#include <stdio.h>
#include <time.h>
#include <algorithm>
#include <unistd.h>
//#include <string.h>
#include <stdlib.h>
#include <sys/times.h>
#define PARENT(i) (i/2)
#define LEFT(i) (2*i)
#define RIGHT(i) (2*i+1)
//test data
#define MAX 1000000

int HEAP_SIZE;
int ARR_LENGTH;

//keep max heap's attribulte
void MAX_HEAPIFY(int  *data, int i);

//build the max heap
void BUILD_MAX_HEAP(int *data);

//heap sort algorithm
void HEAPSORT( int *data);

//get the largest value in heap
int  HEAP_MAXINUM( int *data);

//extract the largest element
int HEAP_EXTRACT_MAX( int *data);

//modify a element, then keep heap's attribute
void HEAP_INSERES_KEY(int *data, int i,int key);

//insert a element to heap
void MAX_HEAP_INSERT( int *data, int key);

void swap( int *data, int i, int j)
{
	int temp = data[i];
	data[i] = data[j];
	data[j] = temp;
}

int main(int argc, char* argv[])
{
	//data[0]不使用
	int data[MAX + 1];
	int i;
	int temp;
	int clock_per_sec = sysconf(_SC_CLK_TCK);
	long beg, end;
	struct tms begTms, endTms;
	srand(time(0));
	ARR_LENGTH = MAX;

	HEAP_SIZE = 0;

	beg = times(&begTms);
	for( i = 1; i <= MAX; i++)
	{
		//data[i] = rand() % MAX;
		MAX_HEAP_INSERT(data, rand() % MAX);
	}
	end = times(&endTms);
	for( i = 1; i <= 10; i++)
	{
		printf("%d\t", data[i]);
	}
	printf("\ntimes: %ld ms\n", (end-beg) * 1000 / clock_per_sec);

}

void MAX_HEAPIFY(int  *data, int i)
{
	int l, r;
	int largest;
	l = LEFT(i);
	r = RIGHT(i);

	//compare its' left children and right children and it's seft
	//find the largest element
	if( l <= HEAP_SIZE && data[l] > data[i])
	{
		largest = l;
	}
	else
	{
		largest = i;
	}

	if( r <= HEAP_SIZE && data[r] > data[largest])
	{
		largest = r;
	}

	//if the largest is parent, then break
	//else, continue heapify.
	if( largest != i )
	{
		swap( data, i, largest);
		MAX_HEAPIFY(data, largest);
	}			
}
void BUILD_MAX_HEAP(int *data)
{
	int i;
	HEAP_SIZE = ARR_LENGTH;
	//Here, assume data[ n/2+1, n] which is leaf node meet max heap's need
	//then ,just adjust other element
	for( i = ARR_LENGTH / 2; i >= 1; i-- )
	{
		MAX_HEAPIFY(data, i);
	}
}
void HEAPSORT( int *data)
{
	int i;
	BUILD_MAX_HEAP(data);
	//extract the largest element from heap once per iterator
	//heap'size will decrease, and keep it's attribute
	for( i = ARR_LENGTH; i >= 2; i-- )
	{
		swap(data,1, i);
		HEAP_SIZE--;
		MAX_HEAPIFY(data, 1);
	}
}

int HEAP_MAXINUM( int *data)
{
	return data[1];
}

int HEAP_EXTRACT_MAX( int *data)
{
	if( HEAP_SIZE < 1 )
	{
		printf("there no element in heap\n");
		return 0;
	}

	int max;
	max = data[1];
	data[1] = data[HEAP_SIZE];
	HEAP_SIZE--;
	MAX_HEAPIFY(data, 1);
	return max;
}

void HEAP_INSERES_KEY(int *data, int i, int key)
{
	if( key < data[i] )
	{
		printf("new key is smaller than current key\n");
		return;
	}
	// replace old element with key, then heapfy
	data[i] = key;
	while( i > 1 && data[PARENT(i)] < data[i])
	{
		swap(data, i, PARENT(i));
		i = PARENT(i);
	}
}

void MAX_HEAP_INSERT( int *data, int key)
{
	// create a element in heap
	// replace negative infinity with key
	HEAP_SIZE++;
	data[HEAP_SIZE] = -100000;
	HEAP_INSERES_KEY(data, HEAP_SIZE, key);
}