排序算法（直接插入排序、希尔排序、堆排序）

排序算法有很多，常见的排序算法有直接插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序，归并排序等。今天来总结一下（直接插入排序、希尔排序和堆排序）

 一、直接插入排序：

给定一组数据，假设要进行升序排序，第一个数默认是升序，从第二个数开始，每次将后一个数插入到这个数的前面的数据中，使这个数之前的数据呈现升序。然后再把下一个数插入到前面数据中，使得前面的数据呈现升序。

插入过程：第一次插入，定义一个end指向第一个元素，tmp存放end的后一个元素，将tmp插入到它前面的数据当中，如果tmp小于a[end]，end--，再与tmp比较，直到tmp大于a[end]或者end小于0，循环结束，将tmp插入到a[end+1]中。再进行下一次插入。

代码块：

//插入排序
//时间复杂度是O(N^2)
//最坏的情况下是逆序  1+2+3+4+(n-1)
void InsertSort(int a[], int n)
{
	
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}

 二、希尔排序

希尔排序（ShellSort）是以它的发明者DonaldShell名字命名的，希尔排序是插入排序的改进版。

多组间隔为gap的预排序，gap由大变小。gap越大，大的数可以越快的到后面，小的数可以越快的到前面。gap越大，预排序完越不接近有序。gap越小，越接近有序。gap等于1时就是直接插入排序。

代码块：

//希尔排序
//直接插入排序基础上的优化
// 1.先进行预排序，让数组接近有序
// 2.直接插入排序
//
void ShellSort(int a[], int n)
{
	int gap = n;
	while (gap > 1)
	{
		// gap大于1时都是预排序
		// gap等于1时是直接插入排序
		//
		gap = gap / 2;
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (tmp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

 三、堆排序

堆的逻辑结构是一颗完全二叉树，堆的物理结构是一个数组。

三个重要公式：

leftchild = parent *2 +1

rightchild = parent * 2 + 2

parent = （child-1)  / 2

再来介绍一下大堆和小堆的概念：

大堆：树中所有的父亲都大于等于孩子；小堆：树中所有父亲都小于等于孩子。

 

 说到堆排序就必须先了解一下向下调整算法： 基本思想 （以建小堆为例）： 1.从根结点处开始，选出左右孩子中值较小的孩子。 2.让小的孩子与其父亲进行比较。3.如果小的孩子比父亲小，应该交换孩子和父亲的值。然后再继续往下调，调到叶子节点终止。

前提：左右子树都是小堆或大堆

建堆：

如果左右子树不是小堆或大堆，就不能直接使用向下调整算法了，可以倒着从最后一颗子树开始调。而叶子不需要调，从倒数最后一个非叶子开始调。

堆排序：

#include <stdio.h>
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}


//向下调整算法
void AdjustDown(int a[], int n, int root)
{
	int parent = root;
	int child = parent * 2 + 1;//左孩子
	while (child < n)
	{
		if (child < n-1 && a[child] < a[child + 1])
		{
			child += 1;//右孩子
		}
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}


void HeapSort(int a[], int n) 
{
	//这里是建大堆
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}

	//要排升序，就要构建最大堆
	//要排降序，就要构建最小堆
	int end = n-1; 
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		end--;
		AdjustDown(a, end, 0);
	}
}