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

常见的比较算法有：



排序算法的稳定性：

假定在待排序的序列中，存在多个相同的关键字，若经过排序，这些关键字的相对次序保持不变，即在原序列中，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)



4000

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
;
_MergeSort(a, tmp, 0, n - 1);
delete[] tmp;
}