堆排序

堆 ，是一种特殊的完全二叉树，采用顺序存储

核心思想：向下调整算法，创建堆，堆顶和最后一个交换，排序

//小堆 条件：左右子树都是堆
void AdjustDown(HpDataType* a, size_t n, int root)
{
	int parent = root;
	int child = parent * 2 + 1;
	while (child < n)
	{
		//找出小的那个孩子
		if (child + 1 < n && a[child+1] < a[child])
		{
			++child;
		}

		//1.孩子比父亲小，则交换，继续往下调整
		//2.孩子比父亲大，则终止调整
		if (a[parent] > a[child])
		{
			/*HpDataType tmp = a[parent];
			a[parent] = a[child];
			a[child] = a[tmp];*/

			Swap(&a[child], &a[parent]);

			parent = child;
			child = parent * 2 + 1;
		}

		else
		{
			break;
		}
	}
}

 

void HeapSort(int *a, int n)
{
	//建堆
	for (int i = (n - 2) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}
	for (int i = 0; i < n; ++i)
	{
		printf("%d ", a[i]);
	}
	printf("\n");

	int end = n - 1;
	while (end>0)
	{
		/*int tmp = a[0];
		a[0] = a[end];
		a[end] = tmp;*/

		Swap(&a[0], &a[end]);

		AdjustDown(a, end, 0);
		--end;
	}

	for (int i = 0; i < n; ++i)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
	
}

代码2 

#include<stdio.h>
#include<stdlib.h>

static void adjustDown(int *data, int size, int m)
{
	int cur = m;
	int n;

	while (cur*2+1<size)
	{
		if (cur * 2 + 2 >= size)
		{
			n = cur * 2 + 1;
		}
		else
		{
			if (data[cur * 2 + 1]>data[cur * 2 + 2])
			{
				n = cur * 2 + 1;
			}
			else
			{
				n = cur * 2 + 2;
			}
		}
		if (data[cur] < data[n])
		{
			int tmp = data[cur];
			data[cur] = data[n];
			data[n] = tmp;

			cur = n;
		}
		else
		{
			break;
		}
	}
}

void swapHeap(int *data, int size)
{
	if (size == 0)
	{
		return;
	}

	int tmp = data[0];
	data[0] = data[size - 1];
	data[size - 1] = tmp;

	adjustDown(data, size - 1, 0);
}

void HeapSorts(int *src, int n)
{
	int i;

	for (i=n/2-1 ; i>=0; i--)
	{
		adjustDown(src, n, i);
	}

	for (; n > 1; n--)
	{
		swapHeap(src, n);
	}
}

void printArray(int *arr, int n)
{
	int i;
	for (i=0; i < n; i++)
	{
		printf("%d", arr[i]);
		putchar('\n');
	}
}

int main()
{
	int data[10] = { 6, 2, 5, 4, 1, 9, 8, 10, 7, 3, };

	HeapSorts(data, 10);
	printArray(data, 10);
	system("pause");
	return 0;
}