插入排序、选择排序、交换排序和归并排序

常见的比较算法有：

排序算法的稳定性：

假定在待排序的序列中，存在多个相同的关键字，若经过排序，这些关键字的相对次序保持不变，即在原序列中，ri=rj，且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的。

一、插入排序

1.直接插入排序

思想：直接插入排序是在已有有序序列的基础上，在最末尾插入一个数，依次起从最大的数开始比较，如果大于最大的数，直接插在该数之后，否则往前进行比较，直到找到自己相应的位置。如果遇到相同的数，则插在该数之后，因此也称直接插入排序是稳定的。时间复杂度O(N^2)

void InsertSort(int *a, int n)
{
	//将取出的数据插入到已有有序序列中
	assert(a);
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end + 1];
		for (; end >= 0; --end)
		{
			if (a[end] > tmp)
			{
				a[end + 1] = a[end];
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}

2.希尔排序

思想：先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2（小于d1)重复上述的分组和排序，直至所取的增量为1， 即所有记录放在同一组中进行直接插入排序为止。希尔排序是对直接插入排序的优化，在完全逆序的情况下，直接插入排序的时间复杂读为O（N^2),而希尔排序经过预排序之后，使时间复杂度小于O（N^2)。

void ShellSort(int *a, int n)
{
	assert(a);

	int gap = n;
	while (gap > 1)
	{
		//预排序完成之后，gap=1,相当于再进行一次插入排序
		gap = gap / 3 + 1;
		//预排序
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = a[end + gap];
			for (; end >= 0; end -= gap)
			{
				if (a[end]>tmp)
				{
					a[end + gap] = a[end];
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

二、选择排序

1.选择排序

思想：选择排序是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始（末尾）位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。时间复杂度：O（N*N)

void SelectSort(int* a, int n)
{
	assert(a);
	size_t begin = 0, end = n - 1;
	while (begin < end)
	{
		size_t min = begin, max = begin;
		for (size_t i = begin; i <= end; ++i)
		{
			if (a[i]<a[min])
			{
				min = i;
			}
			if (a[i]>a[max])
			{
				max = i;
			}
		}

		swap(a[begin], a[min]);
		if (begin == max)
		{
			max = min;
		}
		swap(a[end], a[max]);
		++begin;
		--end;
	}
}

2.堆排序

思想：堆排序是指利用堆积树（堆）这种数据结构所设计的一种排序算法，是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大堆和小堆，是完全二叉树。在数组的非降序排序中，需要使用的就是大堆，根据大堆的性质可知，最大的值一定在堆顶。利用堆的堆顶元素和最末尾的元素进行交换，在对堆进行升序排序，可以依次找到剩余元素里面的最大值，因而可以达到排序的效果。时间复杂度：O（N*lgN)

void AdjustDown(int* a, int n, int root)
{
	int parent = root;
	int child = parent * 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)
{
	assert(a);
	//升序建大堆
	for (int i = (n - 2) / 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;
	}
}

三、交换排序

1.冒泡排序

思想：冒泡排序是比较相邻的两个元素，如果第一个大于第二个，则进行交换，否则不动，所以冒泡排序是稳定的。对该组中的所有相邻元素都进行比较交换，至到最后一个元素，所以最后的元素是最大的。再对最后一个元素之前的所有元素用相同的方法比较，拿到第二个较大的数，直到比较的数只剩下数组中的第一个元素，比较结束。

2.快速排序

思想：通过一趟排序将要排序的数据分割成独立的两部分和一个中间点，其中一部分的数据都比中间点的数据小，另外一部分的数据都比中间点的大。然后对这两部分进行同样的操作，可以用递归方法，使整个数组有序。所以如何找到这个中间数才是关键，有三种方法都可以实现。

1）“左右指针法”

在给定的范围内分别分别拿到头begin和尾end的位置，随机确定一个K值，将a[begin]大于K的值和a[end]小于K的值进行交换，则begin++， --end,最后将begin=end处的值和K进行交换就找到了中间数。

2）挖坑法

随机选定一个数保存起来tmp，认为该数的位置为坑，分别拿到头begin和尾end的位置，若a[begin]大于tmp,则将该数填在坑的位置，a[begin]的位置即为坑然后end开始走，若a[end]小于tmp，则填坑，又会产生新的坑，begin和end交替行走,begi=end时，和tmp进行交换。tmp为中间数。

3）“前后指针法”

定义 cur和prev,当a[cur]小于[prev]且cur和++prev不相邻时，交换cur和prev，否则cur++,直到curd到数组的结尾，交换a[end]和a[++prev].

//左右指针法
int PartSort1(int*a, int begin, int end)
{
	int key = end;

	while (begin < end)
	{
		while (begin < end && a[begin] <= a[key])
		{
			begin++;
		}
		while (begin < end && a[end] >= a[key])
		{
			--end;
		}

		if (begin < end)
		{
			swap(a[begin], a[end]);
		}
	}
	swap(a[begin], a[key]);
	return begin;
}

//挖坑法
int PartSort2(int*a, int begin, int end)
{
	int tmp = a[end];
	while (begin < end)
	{
		while (begin < end && a[begin] <= tmp)
		{
			++begin;
		}
		a[end] = a[begin];
		while (begin < end && a[end] >= tmp)
		{
			--end;
		}
		a[begin] = a[end];
	}
	swap(a[begin], tmp);
	return begin;
}

//前后指针法
int PartSort3(int*a, int begin, int end)
{
	int cur = begin;
	int prev = cur - 1;

	while (cur < end)
	{
		if (a[cur] < a[end] && ++prev != cur)
		{
			swap(a[cur], a[prev]);
		}
		++cur;
	}
	swap(a[++prev], a[end]);
	return prev;
}

void QuickSort(int* a, int begin, int end)
{
	if (begin < end)
	{
		//int pos = PartSort1(a, begin, end);
		//int pos = PartSort2(a, begin, end);
		int pos = PartSort3(a, begin, end);

		QuickSort(a, begin, pos - 1);
		QuickSort(a, pos + 1, end);
	}
}

四、归并排序

思想：通归并排序是分治法的一个非常典型的应用。即先使每个子序列有序，再将已有序的子序列合并，得到完全有序的序列。

//归并排序
void Merge(int* a, int* tmp, int begin1, int end1, int begin2, int end2)
{
	int start = begin1;
	int finish = end2;
	int index = begin1;

	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
		{
			tmp[index++] = a[begin1++];
		}
		else
		{
			tmp[index++] = a[begin2++];
		}
	}

	while (begin1 <= end1)
	{
		tmp[index++] = a[begin1++];
	}

	while (begin2 <= end2)
	{
		tmp[index++] = a[begin2++];
	}

	memcpy(a + start, tmp + start, (finish - start + 1)*sizeof(int));
}

void _MergeSort(int* a, int* tmp, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}

	int mid = begin + (end - begin) / 2;
	_MergeSort(a, tmp, begin, mid);
	_MergeSort(a, tmp, mid + 1, end);

	Merge(a, tmp, begin, mid, mid+1, end);
}

void MergeSort(int* a, int n)
{
	assert(a);

	int* tmp = new int[n];
	_MergeSort(a, tmp, 0, n - 1);
	delete[] tmp;
}