【算法】排序1：直接插入排序、希尔排序、选择排序、堆排序

排序在许多地方都有应用，常见的排序算法可以分为插入排序、选择排序、交换排序、归并排序四类。

• 插入排序
  插入排序又可以分为两种：
  ①直接插入排序
  ②希尔排序

直接插入排序就是把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列，直接插入排序的时间复杂度为O(N^2)

void InsertSort(int*a, int n) 
{
     
	//控制end的位置从2走到n-2
	for (int i = 0; i < n - 1;++i)
	{
     
		//单趟排序 在[0,end]区间中插入tmp，依旧有序
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
     
			if (a[end]>tmp)
			{
     
				a[end + 1] = a[end];
				--end;
			}
			else
			{
     
				break;
			}
		}
		a[end + 1] = tmp;
	}
}

希尔排序是先选定一个整数gap，把待排序文件中所有数据分成gap个组，所有距离为gap的数据分在同一组内，并对每一组内的数据进行排序。当gap==1时，所有数据完成排序，平均时间复杂度O（N^1.3），最坏情况是顺序有序。

void ShellSort(int* a,int n)
{
     
	int gap = n;//间隔为gap的预排序
	while (gap > 1)
	{
     
		gap = gap / 3 + 1;//+1保证最后一次是1
		for (int i = 0; i < n - gap; ++i)
		{
     
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
     
				if (a[end] > tmp)
				{
     
					a[end + gap] = a[end];
					end -= gap;
				}
				else{
     
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

• 选择排序
  选择排序也可以分为两种：
  ①选择排序
  ②堆排序

选择排序就是每一次从待排序的数据元素中选出最小和最大的一个元素，存放在序列的起始位置和末尾位置，直到全部待排序的数据元素排完 ，时间复杂度O（N^2），不推荐使用。

void Swap(int* p1, int* p2)
{
     
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
void SelectSort(int* a,int n)
{
     
	int begin = 0;
	int end = n - 1;
	//[begin,end]选出一个最小的，选出一个最大的数的下标
	while (begin < end)
	{
     
		int mini = begin;
		int maxi = end;
		for (int i = begin; i <= end;++i)
		{
     
			if (a[i]>a[maxi])
			{
     
				maxi = i;
			}
			if (a[i]<a[mini])
			{
     
				mini = i;
			}
		}
		Swap(&a[begin], &a[mini]);
		if (begin == maxi)
		{
     
			maxi = mini;
		}
		Swap(&a[end], &a[maxi]);
		++begin;
		--end;
	}
}

堆排序是使用堆这种数据结构来排序，排升序时要建小堆，时间复杂度为O（N*logN）。

void AdjustDown(HpDataType*a,size_t n, HpDataType root) //向下调整算法 调堆
{
     
	int parent = root;
	int child = parent * 2 + 1;
	while (child<n)
	{
     
		if (child+1 < n && a[child+1] > a[child])
		{
     
			++child;
		}
		if (a[parent]<a[child])
		{
     
			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]);
		AdjustDown(a, end, 0);
		--end;
	}
}