數據結構中的排序--堆（heap）排序

堆排序的相關理論和概念可以參考網絡上的資源。

堆排序涉及到的主要是完全二叉樹，以及堆的理解。

堆在排序中的作用是在一個完全二叉樹中選出待排序數據中的最大或者最小的值，並將這個值放置於根節點。每次只需要將根節點的值取出，放到已排好序的數列中。剩下的數據繼續組成一個堆，再取出根節點放到已排好序的數列後面，一直到堆中的數據取完爲止。

這裏面比較重要的就是堆的構建，涉及到左右子節點以及遞歸的使用。

#include "stdafx.h"
#include <iostream>
using namespace std;

void print(int data[], int n)
{
	for (int i = 0; i < n; i++)
	{
		cout << data[i] << " ";
	}
	cout << endl;
}

int heap_size;
int left_index(int index)
{
	return ((index << 1) + 1);
}
int right_index(int index)
{
	return ((index << 1) +2);
}

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

void max_heapify(int data[], int index)
{
	int maxdata_index = 0;
	int left = left_index(index);
	int right = right_index(index);

	if ((left <= heap_size) && (data[left] > data[index]))
		maxdata_index = left;
	else
		maxdata_index = index;

	if ((right <= heap_size) && (data[right] > data[maxdata_index]))
		maxdata_index = right;

	if (maxdata_index != index)
	{
		swap(&data[maxdata_index], &data[index]);
		max_heapify(data, maxdata_index);
	}
}
void build_heap(int data[], int len)
{
	heap_size = len;

	for (int i = (len >> 1); i >=0; i--)
	{
		max_heapify(data, i);
	}
}
void heap_ascending_sort(int data[], int len)
{
	int i = 0, j = 0, temp = 0, x = 0;

	build_heap(data, len-1);

	for (i = (len - 1); i >=1; i--)
	{
		swap(&data[0], &data[i]);
		heap_size--;
		max_heapify(data, 0);
	}
}


void min_heapify(int data[], int index)
{
	int mindata_index;
	int left = left_index(index);
	int right = right_index(index);

	if ((left <= heap_size) && (data[left] < data[index]))
		mindata_index = left;
	else
		mindata_index = index;

	if ((right <= heap_size) && (data[right] < data[mindata_index]))
		mindata_index = right;

	if (index != mindata_index)
	{
		swap(&data[index], &data[mindata_index]);
		min_heapify(data, 0);
	}
}
void heap_desending_sort(int data[], int len)
{
	int i = 0, j = 0, temp = 0, d = 0;

	heap_size = len - 1;
	for (i = ((len -1) >> 1); i >= 0; i--)
	{
		min_heapify(data, i);
	}

	for (i = (len - 1); i >= 1; i--)
	{
		swap(&data[0], &data[i]);
		heap_size--;
		min_heapify(data, 0);
	}

}


int main()
{
	int num[] = {5,3, 7,4,3,9,6,2,10,4,3,7,1};
	int len = sizeof(num) / sizeof(int);

	cout << "data count:"<< len << ".  before sort: ";
	print(num, len);

	heap_ascending_sort(num, len);
	cout << "after ascending sort: ";
	print(num, len);

	heap_desending_sort(num, len);
	cout << "after desending sort: ";
	print(num, len);

	return 0;
}