@[学习笔记1——算法—排序（插入排序、希尔排序、堆排序、快排）]

#排序
排序基于是否比较被排数列大小，分为比较排序与比较排序，其中非比较排序有计数排序法，比较排序有常用的冒泡排序、选择排序、插入排序、希尔排序、堆排序、快排、归并排序。
##目录
（一）排序方法介绍
1.插入排序
2.希尔排序
3.堆排序
4.快排
（二）各种排序特点及适用总结
##各种排序方法介绍（假设升序）
#插入排序

插入排序思想：选择一个数x插入某个“ 有序”数列arr。从arr最后一个数向前逐个比较，如数列中最后一个数为end，end大于x则end向后移动一位，直到某个数小于x则放在这个数后面，或者x最小则放在最前面。
算法实现：
‘’’
//插入排序思想是从第一个数开始，选后面一个数，前面的数进行比较。
//如果前面的数//比这个数大，则将前面的数向后移动一位，直到第一个数移至第二位，
// 选的数放第一位，或者前数比选中数小，那么放在选中数后面一位；
//end从第一个数开始， 被选数x从end+1开始

 void InsertSort(int* a, int n)
{
	int i = 0;
	for (i = 0; i < n-1 ; i++)
	{
		//单次的
		int end = i;
		int x = a[end + 1]; //end+1被记录，所以不会被覆盖数据
		while (end >= 0)
		{
			if (a[end] > x)
			{
				a[end + 1] = a[end];
				end--;
			}//if
			else
			{
				break;
			}
		}
		a[end + 1] = x;
	}
}

'''

#希尔排序
希尔排序是一种能够应对各种场景，如数列全为单值的数列、已经有序的数列等各种场景的数列。希尔排序基于插入排序思想来，如果插入数列基本有序，则while循环的次数将大大减少。基于将数列进行预先排序的思想,对插入排序进行优化。

‘’’

//希尔算法主要是对插入算法有个预排序调整。
//通过一个间距变量gap选出不同分组，在分组内现排序，不同分组排序完成后数组顺
//序大致已经排列好，再通过gap等于1时退化为插入排序进行一次排列，虽然麻烦
//但是效率好高，基本时间复杂度为N^1.3。

void ShellSort(int* a, int n)
{
int gap = n;//这个gap选择是关键，如果从 10以下开始选，则优化不明显
                 //gap越大，gap内的元素越小，gap划分的数组越多，循环的出口是gap=1；gap--是循环退出的路径
                 //当gap=1时，希尔排序退化为插入排序，但是因为数列已经基本排好，所以很快
	//先写单次预排的
	//再写各组一锅炖的
	//再写一个控制gap的
	while (gap > 1)
	{//while1
		gap =gap/3+1;
		
		int i = 0;
		for (i = 0; i < n - gap; i++)
		{
			//n-gap是关键因为最后一个数的下标应该是n-1那么最后一个end的
			//位置应该是n-gap-1,所以是小于n-gap
			int end = i;
			int x = a[end + gap];
				while (end >=0)
				{
					if (a[end] > x)
					{
						a[end + gap] = a[end];
						end -= gap;
					}//if
					else
					{
						break;
					}//else
				}//while
		a[end + gap] = x;
		}
		

	}
	}

‘’’
#堆排序
堆排序是借助二叉树，堆结构来进行排序，排升序用大堆（大堆：及树的所有根节点大于子节点的树），排降序用小堆。要借助二叉数排序是将一个大堆的根节点和最后一个叶子节点交换，然后将除最后一个叶子节点以外的节点在进行向下调整（大堆），此时第二大的节点再次形成根节点。重复进行则完成升序排序。降序同样，只是用小堆就行。

‘’’
图片好像用的是向上调整，但是向下调整一般来说要快一点。代码用向下调整实现，差别在于向上调整第一次是从前面向后面调，第二次是后面从前调，而向下调整是第一遍后面向前调成大堆（因为二叉树无序时，向下调整从前向后没法调）。（很简单，自己随便画个二叉树就知道了）
/升序建大堆
//向下调整，如果是子节点大于父节点，则父节点向下，子节点向上
//通过递归的方式

void AdjustDwon(int* a, int n, int root)
{
	int parent = root;
	int child = root * 2 + 1;
	while (child<n)
	{
		if (child + 1 < n && a[child + 1]>a[child])
		{
			child++;
		}
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
		
	}
}
void HeapSort(int* a, int n)
{
	//堆排序，先建大堆
	int root = n ;
	for (int i = (n - 2)/2; i >=0; i--)
	{
		AdjustDwon(a, n, i);
	}
	//将最大的根节点 a[0]和 a[end]交换，对0 至  end-1 排序
	for (int i = n - 1; i > 0; i--)
	{
		Swap(&a[0], &a[i]);
		AdjustDwon(a, i, 0);
	}

}

'''

#快速排序
快速排序是用递归实现，总的来看像构建了一个二叉树，每次递归可确定一个数，所以直接先理解一遍排序的过程，在理解递归过程就很明确了。没找到和是的图，就不放图了吧，很接单，可以自己画一下。每次递归的目的是将关键值放在正确的位置，先找到一个关键值，一般用最左边的来，key=arr[0]，然后设定两个下标，如果最左边的数当关键值，则从最右边的小标开始移动，直到两个光标相遇或者错过。右边光标发现比关键值小的值就停止，左边光标开始向右，发现比key大的就停下来和右边光标的数交换。最后两光标相遇，一定是左右下标相遇的数比key小（左下标遇右下标，说明相遇下标前的数都比key小，右下标遇左下标说明下标后的数都比key大，这就是为什么选左让右下标先动）。key找到后接下来就进入递归，[0,key_i-1] key位置坐标的数组进行递归，[key+1,n-1]右边的进行递归，递归的出口为左右下标相遇了。
‘’’
先写单趟的：

int Partern(int* a, int left, int right)
{
	int midd_i = GetMidd(a, left, right);//这是优化三数取中
	Swap(&a[midd_i], &a[left]);//这是优化三数取中
	int keyi = left;
	while (left < right)
	{
		while (a[right] >= a[keyi] && left < right)
		{
			right--;
		}
		while (a[left] <= a[keyi]&&left<right)
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[left], &a[keyi]);
	return left;
}
void QuickSort(int* a, int left,int right)
{
	
	if (left >= right) //这是递归出口
	{
		return;
	}
	if (right - left +1< 10)//先不看这，这是扣划的
	{
		ShellSort(a+left, right - left + 1);
	}
	else
	{
	int keyi = Partern(a, left, right);//单趟排好后
	QuickSort(a, left, keyi-1);//进入递归，有点像二叉树左子树
	QuickSort(a, keyi + 1,right );//这是右子树
	return;
	}
}

‘’’
快排有几个缺点：
1.当数列有序时，时间很慢，因为每次单趟右下标都要走完，
2.不断递归开销很大，数列越接近有序，越接近最坏情况的0（n^2）的时间复杂度，
优化：三数取中
第二，当数列原本很大，但是递归到只有10个数的时候，栈开销会很大，所以将小数列优化为插排
‘’’

	int GetMidd(int* a, int left, int right)
{
	int midd_i = left + ((right - left) >> 1);
	midd_i = a[left] > a[right] ? a[right] > a[midd_i] ? right : a[left] > a[midd_i] ? midd_i : left : a[left] > \a[midd_i] ? left : a[right] > a[midd_i] ? midd_i : right;
	return midd_i;


}

‘’’
#（二）各种排序特点及适用总结
先上图：

整体来看希尔、堆排、快排的平均情况时间复杂度都还不错，比冒泡，选择排序好，计数排序虽然没有写，但是计数排序由于将位置偏移量作为数值来用，所以只适用于整体范围较小，且数值为整数的排序。快排需要优化，不然特殊数列排序较慢。
整体来看，希尔排序适用范围最广，对1000万个数排序，还是希尔仍跟快排差不多。堆排序也不错。