直接插入排序，希尔排序，选择排序，堆排序

 今天学到排序这一块了，就来也总结一下今天学到的4个排序，若表述有错误，恳请指正！

直接插入排序

直接插入排序
a:待排序数组
n:数组长度
思想（升序）：
1、从数组0开始，其后一个数则为待插入数据
2、与该范围[0, i]的每个数进行从后往前的比较
3、当遇到比自己大的数就让大的数往后移动一个位置，然后再与后一个数进行比较
4、直到遇到比自己小的数的时候，就将该数插于其后，此刻循环结束
5、当比较扔每找到比自己小的数，就插入到首部，此刻循环结束
时间复杂度：O(N^2)，逆序情况下，就是N^2

void InsertSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int x = a[end + 1];
		while (end >= 0)
		{
			if (a[end] > x)
			{
				a[end + 1] = a[end];
				--end;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = x;
		//ArrPrint(a, n);
	}
}

希尔排序

希尔排序是学到今天觉得第二个比较复杂的排序算法，另一个就是堆排序，这个算法很有意思，是在直接插入排序的基础上进行了一个预排序，而之前的直接插入排序如果遇到逆序，或是接近逆序的数组，那么时间复杂度将非常高，而希尔排序算法则可以通过预排序阶段将数据尽可能的有序化，避免的大数据的多次替换，其核心思想在我看来就是将一个数组划分成多个小数组，对小组数组进行直接插入排序，然后再参与较大数组的直接插入排序，往复进行此操作，可以使数据尽可能的有序化，下面的代码中有两段代码，方式一较好理解

希尔排序

我称其为跳跃式直接插入排序
a:待排序数组
n:数组长度

1、从数组0开始，其后0 + gap（下标）数则为待插入数据
2、与该范围的每个数进行从后往前的比较
3、当遇到比自己大的数就让大的数往后移动一个位置，然后再与后一个数进行比较
4、直到遇到比自己小的数的时候，就将该数插于其后，此刻循环结束
5、当比较扔每找到比自己小的数，就插入到首部，此刻循环结束
比较部分共有两个函数出口
时间复杂度：O(N^2)，整个数据是逆序或者接近逆序

void ShellSort(int* a, int n)
{
	//方式2
	for (int gap = n; gap > 1; gap /= 2)//定义gap的长度初始为n，后面每进行一次调整gap就缩减为原先的一半
	{
		for (int i = 0; i < n - gap; i++)//这种方式相当于第一种方式，这种方式是让每一组同时排序，方式一是让一组排完再排下一组，并且i < n - gap的原因是不能越界
		{
			int end = i;
			int x = a[end + gap]; //x为当前位置下一个要加入进来的值
			while (end >= 0)//进行值得对比交换
			{
				if (a[end] > x)
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = x;
		}
	}

		//方式1
	for (int gap = 0; gap > 0; gap /= 2)
	{
		for (int j = 0; j < gap; j++)
		{
			for (int i = j; i < n - gap; i += gap)
			{
				int end = i;
				int x = a[end + gap];
				while (end >= 0)
				{
					if (a[end] > x)
					{
						a[end + gap] = a[end];
						end -= gap;
					}
					else
					{
						break;
					}
				}
				a[end + gap] = x;
			}
		}
	}
}

选择排序

功能:选择排序（双数）
说明：这个选择排序相对于单数的排序，量上面会快一点，但是质上面不会提升
a:待排序数组
n:数组长度
1、先随便指定一个数，假设其即为最大数，也是最小数

2、有两个变量，一个记录最小坐标的mini 一个记录最大坐标的maxi

3、有两个变量，一个在数组头部begin，一个在数组尾部end，用来标识数组大比较范围

4、遍历数组，，当遇到比mini下标所代表的数还小的时候就更新mini的下标，最大数同理
5、结束条件为begin >= end，当达到此条件就停止运算
时间复杂度：O(N^2)，这个函数实现简单，但是时间复杂度很差，无论最好情况还是=最坏情况，都是O(N^2)

void SelectSort(int* a, int n)
{
	//初始化的时候将begin置0，end置n - 1，一个在数组首，一个在数组尾
	int begin = 0;
	int end = n - 1;
	
	//相遇条件
	while (begin < end)
	{
		//在开始的时候给他们任意合法下标
		int mini = begin;
		int maxi = end;
		for (int i = begin; i <= end; ++i)
		{
			if (a[mini] > a[i])
				mini = i;
			if (a[maxi] < a[i])
				maxi = i;
		}
		Swap(&a[begin], &a[mini]);
		if (begin == maxi)//当第一个为最大数的时候，此时最小的数跟该位置已经交换了，接下来，maxi指向的位置正是此处，那么就会导致数据错乱
			maxi = mini;
		Swap(&a[end], &a[maxi]);
		++begin;
		--end;
	}
}

堆排序

功能：堆排序
a:待排序数组
n:数组长度
思想：利用大堆/小堆的特性，来实现排序
大堆：最顶部的一定是最大数，但无法确定第二大数
小堆：最顶部的一定是最小数，但无法确定第二小数
1、先建立大堆（升序）/小堆（降序）

2、知道a[0]那么就可以确保最大数找到了

3、a[0]与a[n - 1]进行交换，此刻最后一个为最大数/最小数
4、此刻再对顶部数据进行一次向下调整，重新筛选出最大数/最小数

5、如此往复就实现了升序/降序排序

/*功能:堆的向下调整
* data:待排序数组
* size:要进行调整的大小
* parent:父节点，根据该节点以及size从而找出子节点
*/
void AdjustDown(int* data, int size, int parent)
{
	//在Pop的时候进行小堆/大堆排序
	//大堆排序方式，利用了堆的一个规律：
	//parent = (child - 1) / 2
	//左孩子 = parent * 2 + 1
	//右孩子 = parent * 2 + 2

	//先找到孩子节点，此刻不用一次性定义两个孩子，不然不好判断
	int child = parent * 2 + 1;
	while (child < size)//前提条件是，child不能超过size，如果超过就代表越界了
	{
		if (child + 1 < size && data[child + 1] < data[child])//小堆排序，选出小孩子
			//if (child + 1 < size && data[child + 1] > data[child])//大堆排序，选出大孩子
			++child;
		if (data[child] < data[parent])//如果parent节点比child节点小=
			//if (data[child] > data[parent])//大堆排序进行交换
		{
			Swap(&data[parent], &data[child]);
			parent = child;
			child = parent * 2 + 1;//这里赋值，之后进入while循环就可以判断是否越界
		}
		else
		{
			break;
		}
	}
}


void HeapSort(int* a, int n)
{
	//建大堆，保证最上面为最大值   a[0]
	//建小堆，保证最上面为最小值   a[0]
	//建堆时间复杂度;O(N)
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}
	//换数，因为a[0]为最大数，将其换在最后面，就可以进行升序排序
	//换数，因为a[0]为最小数，将其换在最后面，就可以进行降序排序
	//比较时间复杂度：O(NlogN)
	for (int i = n; i > 0; i--)
	{
		Swap(&a[0], &a[i - 1]);
		AdjustDown(a, i - 1, 0);
	}
}

 快速排序

快速排序的思想：第一次排序以一个数为基准，然后分割整个数组，将大于基数的放在右边，小于基数的放在左边，两边的数再找一个数分别为基数，再次分割了，依次类推，直至排序完成，详细的可以看下面的图解

其中有3中方法，由于今天只学了两种方法，第三种方法就留着下次学完了，再来写

额外 需要使用到的函数：

Swap(int* px, int* py) 两数交换

/*
* 功能：两数交换
*/
void Swap(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}

GetMiniIndex(int* a, int left, int right) 三数选中数
功能：选出三个数中的中间数
1、先将中数的坐标求出来
2、然后将中数与a[left]进行比较
3、若a[left] < a[mini]，再与a[right]进行比较
4、如果a[mini] < a[right]，那么a[mini]就是中间数
5、如果4不成立，那么此刻，a[mini] > a[left] && a[mini] > a[right]，判断a[left]与a[right]谁更大就得出谁是中间数了
6、若3不成立，就比较小，方法与上述类似

int GetMiniIndex(int* a, int left, int right)
{
	int mini = left + ((right - left) >> 1);//这样求中数，主要是为了避免遇到INT_MAX，进行移位运算相对于进行除法运算来说会更快

	if (a[left] < a[mini])
	{
		if (a[mini] < a[right])//此时a为中间数
			return mini;
		else if (a[right] > a[left])//此时a最大，判断另外两个数谁更大
			return right;
		else
			return left;
	}
	else
	{
		if (a[mini] > a[right])//此时a为中间数
			return mini;
		else if (a[right] < a[left])//此时a最小，判断另外两个数谁更小
			return right;
		else
			return left;
	}
}

方法一：hoare

功能：快速排序的单趟排序（方法一：    hoare）
a:待排序数组
left:数组左区间
right：数组右区间
时间复杂度：O(N)
1、先将左边设置为keyi
    注意：设置左边为keyi就从right开始移动，设置右边为keyi就从left开始移动
2、对right进行判断，找出一个比a[keyi]小的数，然后right停止
3、对left进行判断，找出一个比a[keyi]大的数，然后left停止
4、交换a[left],a[right]，继续上述2/3操作，直至left与right相遇
5、将相遇位置与a[keyi]进行交换
6、返回left/right作为下一次排序的新keyi

int Partion1(int* a, int left, int right)
{
	int mini = GetMiniIndex(a, left, right);
	Swap(&a[left], &a[mini]);
	int keyi = left;
	while (left < right)
	{
		while (left < right && a[right] >= a[keyi])
			--right;
		while (left < right && a[left] <= a[keyi])
			++left;
		Swap(&a[left] , &a[right]);
	}
	Swap(&a[keyi], &a[left]);
	return left;
}

方法二：挖坑法

功能：快速排序的单趟排序（方法二：挖坑法）
a:待排序数组
left:数组左区间
right：数组右区间
1、选出三个数中的中间数
2、保存第一个值至变量pit中
3、先将左边设置为keyi
    注意：设置左边为keyi就从right开始移动，设置右边为keyi就从left开始移动
4、对right进行判断，找出一个比pit小的数，然后right停止
5、将a[left]与a[right]互换
6、对left进行判断，找出一个比pit大的数，然后left停止
7、将a[right]与a[left]互换
8、继续返回步骤4，直至left >= right
9、将相遇位置的值与pit互换
10、函数结束，返回left，做为下次的新keyi

int Partion2(int* a, int left, int right)
{
	int mini = GetMiniIndex(a, left, right);
	Swap(&a[left], &a[mini]);

	int keyi = left;
	int pit = a[keyi];
	while (left < right)
	{
		while (left < right && a[right] >= pit)
			--right; 
		Swap(&a[left], &a[right]);
		while (left < right && a[left] <= pit)
			++left;
		Swap(&a[left], &a[right]);
	}
	a[left] = pit;
	return left;
}

/*功能：快速排序
* a:待排序数组
* left:数组左区间
* right：数组右区间
* 使用Partion1函数进行单趟排序，如果不进行三数选中数操作，时间复杂度最坏将达到O(N^2)逆序，最好情况下O(N*lobN)乱序
*  使用Partion2函数进行单趟排序，可以很好地规避逆序的情况，时间复杂度：O(N*logN)
*/
void QuickSort(int* a, int left, int right)
{
	if (left >= right)
		return;

	int keyi = Partion2(a, left, right);
	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}

主函数

#define MAXLEN 10

#include "sort.h"

void TestInsertSort()
{
	int a[MAXLEN] = { 0 };
	srand(time(0));
	int num = MAXLEN;
	while (num--)
		a[num] = rand() % 200;
	//a[0] = 200;
	printf("raw data:");
	ArrPrint(a, sizeof(a) / sizeof(a[0]));


	int begin1 = clock();
	InsertSort(a, sizeof(a) / sizeof(a[0]));
	int end1 = clock();
	printf("InsertSort data:"); ArrPrint(a, sizeof(a) / sizeof(a[0]));
	printf("time of InsertSort :: %d\n\n", end1 - begin1);

	int begin2 = clock();
	ShellSort(a, sizeof(a) / sizeof(a[0]));
	int end2 = clock();
	printf("ShellSort data:"); ArrPrint(a, sizeof(a) / sizeof(a[0]));
	printf("time of ShellSort :: %d\n\n", end2 - begin2);

	int begin3 = clock();
	SelectSort(a, sizeof(a) / sizeof(a[0]));
	int end3 = clock();
	printf("SelectSort data:"); ArrPrint(a, sizeof(a) / sizeof(a[0]));
	printf("time of SelectSort :: %d\n\n", end3 - begin3);

	int begin4 = clock();
	HeapSort(a, sizeof(a) / sizeof(a[0]));
	int end4 = clock();
	printf("HeapSort data:"); ArrPrint(a, sizeof(a) / sizeof(a[0]));
	printf("time of HeapSort :: %d\n\n", end4 - begin4);

	

}

时间对比：

 结果截图：