排序算法1：堆排序，直接插入排序与希尔排序

前言

前些时间，博主带领着大家学习了数据结构，数据结构中的二叉树更是其中的重中之重，我们之前了解了二叉树是现实计算机存储数据的一种重要形式。借助其结构，我们还能实现更多高效的功能。

今天我们将进入排序算法的章节，首先我们会先学习，基于二叉树顺序结构—堆， 而实现的堆排序，还有两种重要的排序方法，直接插如排序和希尔排序，同时我们将探讨他们的排序时间复杂度。

好，废话不多说，开始我们今天的正题：

1.堆排序

在我们上次刚实现二叉树顺序结构的基础上，我们根据这个排序的名字就能够知道，这个·排序的的实现逻辑与堆有关系，所以如果我们有一个如下的数组，我们要怎样的排序呢？

不了解二叉树顺序结构的同学，可以先去看看我之前的这篇文章：http://t.csdnimg.cn/A165d

int arr[] = {17, 20, 10, 13, 19, 15}

1.1建堆

首先我们还是要建成一个堆的结构：

我们需要像之前一样，通过HPPush函数将所有的元素都推进一个新创建的堆中吗？

如果是这样的话，我们的空间复杂度就会变为O(n),对我们的程序运行并不是很友好。

那我们可以怎样来建成一个堆呢？

还记得我们在实现二叉树结构的向上、向下调整算法吗？

void AdjustUp(HpDataType* arr, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (arr[child] > arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			child = parent;
			parent = (child - 1 )/ 2;
		}
		else
		{
			break;
		}
	}
}
void AdjustDown(int* arr, int parent, int n)
{
	int child = parent  * 2 + 1;
	if (arr[child] < arr[child + 1])
	{
		child++;
	}
	while (child < n)
	{
		if (arr[child] > arr[parent])
		{
			Swap(&arr[parent], &arr[child]);
			parent = child;
			child = 2 * parent + 1;
		}
		else
			break;
	}
}

其实，二叉树的顺序结构堆的底层结构就是数组，那我们就只需要将数组中的元素进行向上向下的调整，就可以建成我们需要的大堆（小堆）了。

int main()
{
	int arr[] = { 17, 20, 10, 13, 19, 15 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < sz; i++)
	{
		AdjustUp(arr, i);
	}

	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

我们可以看到，通过向上调整算法，就可以在原数组的基础上直接建成大堆！！

1.2排序 

根据大小堆的性质，我们可以这样来进行排序呢？

我们先来看看我们已经建成的大堆：

大堆，就是整个数组最大的值放在了堆顶。相反，小堆的堆顶元素就是最小值。

所以如果我们要进行升序操作，我们可以将堆顶的元素与堆尾的元素交换位置，同时缩小向下调整的范围，就可以得到排序的结果。 

 

代码实现：

int main()
{
	int arr[] = { 17, 20, 10, 13, 19, 15 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < sz; i++)
	{
		AdjustUp(arr, i);
	}
	int end = sz - 1;
	while (end > 1)
	{
		Swap(&arr[0], &arr[end]);//交换堆顶和堆尾的数据
		AdjustDown(arr, 0, end);
		end--;//缩小调整范围
	}
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

这样，堆排序就完成了！！ 

接下来我们想要实现数组元素的降序，我们该怎么办呢？

不难看出，我们想要实现降序就要通过建小堆，所以我们就要在建堆的操作上下功夫：

void AdjustUp(HpDataType* arr, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (arr[child] < arr[parent])//当子节点的值比父节点的小时，进行交换，如此堆顶的元素就是最小的元素
		{
			Swap(&arr[child], &arr[parent]);
			child = parent;
			parent = (child - 1 )/ 2;
		}
		else
		{
			break;
		}
	}
}

 ，可以发现，我们现在就成功的建成了一个小堆。

接下来，我们再将向下调整算法，修改一下。

void AdjustDown(int* arr, int parent, int n)
{
	int child = parent  * 2 + 1;
	if (arr[child] > arr[child + 1])//降序时，要找出左右子节点中值较小的那个
	{
		child++;
	}
	while (child < n)
	{
		if (arr[child] < arr[parent])//子节点比父节点值小时交换，堆顶的元素就是堆中排序范围中最小的那个
		{
			Swap(&arr[parent], &arr[child]);
			parent = child;
			child = 2 * parent + 1;
		}
		else
			break;
	}
}

 这样我们就轻松的实现了数组的降序排列

2.直接插入排序

当插入第i（i>=1）个元素时,前面的arr[0], arr[1],....arr[1 - 1]已经排序好了，此时用arr[i]的排序码与arr[i - 1]，arr[i - 2],...的排序码顺序进行比较，找出插入位置将arr[i]插入，原来位置上的数据后移。

 这里我们画图理解一下，这个排序算法的思想：

加入我们现在有这样的数组：

接下来我们按照这个思路来实现代码：

void InsertSort(int* arr, int n)
{
	for (int i = 0; i < n - 1; i++)//注意讨论界限
	{
		int end = i;
		int tmp = arr[end + 1];
		while (end >= 0)
		{
			if (arr[end] < tmp)//<时排降序，>排升序
			{
				arr[end + 1] = arr[end];
				end--;
			}
			else
				break;
		}
		arr[end + 1] = tmp;
	}
}

 我们来验证一下：

直接插入排序就实现了。

3.希尔排序

希尔排序有被称之为缩小增量法。希尔排序法的基本思想是：先选定一个整数（通常gap = n / 3 + 1），把待排序的文件所有记录分成各组，所有的距离相同的记录分在同一组内，并对每一组内的记录进行排序，然后将gap = gap / 3 + 1得到下一个整数，再将数组分成各组，进行插入排序，当gap = 1时，就相当于进行直接插入排序。

他是在直接插入排序的基础上进行优化得来的，综合来说他的效率要高于直接插入排序！！

void ShellSort(int *arr, int sz)
{
	int gap = sz;
	while (gap > 1)//在gap等于1之前的排序，我们都可以看做是预排序，可以让小的数据先出现在前面，大的数据出现在后面，
	{//从而是排序的时间复杂度降低
		gap = gap / 3 + 1;
		for(int  i = 0; i < sz - gap; i++)
		{
			int end = i;
			int tmp = arr[end + gap];
			while (end >= 0)
			{
				if (arr[end] > tmp)
				{
					arr[end + gap] = arr[end];
					end -= gap;
				}
				else
				break;
			}
			arr[end + gap] = tmp;
		}
	}
}

好，今天的内容就到这里，我们下期再见！！