直接插入排序，堆排序，快速排序，归并排序（C++语言）

一.直接插入排序

直接插入排序的基本思想是：将一个记录插入到一组已排序好的有序表中，这样，最后所得的数据就全部都是已排好序的。

在对数组的排序之中，一般是将第一个元素作为已排好序的数组，后面的元素为待排数组，每一次取未好数组的第一个，然后在已排好序的数组中寻找到它应该插入的位置，将该元素插入其中，直到所有元素均被排好。

代码：

#include<iostream>
#include<ctime>
using namespace std;
void InsertSort(int a[200])
{
    for (int i = 1; i < 200; i++)
    {
        int temp = a[i];
	int m = i;
	for (int j = i-1; j >=0; j--)
	{
	    if (temp < a[j])
	    {
		a[m] = a[j];
		a[j] = temp;
		m = j;
	    }
	    else if (temp > a[j])
		break;
        }
    }
}
int main()
{
    int a[200],i=0;
    srand(i);
    for(int j=0;j<200;j++)
    {
        a[j]=rand()%5000;
        i++;
    }
    InsertSort(a)
    for(int j=0;j<200;j++)
        cout<<a[j]<<" ";
}

二 .堆排序

堆排序的主要思路是先将待排的数组构建为一个大顶堆（或小顶堆），然后将堆顶的元素与最后一个元素进行互换（如果是小顶堆则不变），之后再对剩余的元素进行重构堆和交换操作（小顶堆不用进行交换），直到结束为止，最后得到的结果就是一个从小到大已排序的数组。

堆排序的空间复杂度为0，所以它不用消耗额外空间，但是它的稳定性不好。

代码：

#include<iostream>
#include<ctime>
using namespace std;
void HeapSort(int a[200])
{
    for (int i = 199; i >0; i--)
    {
        for (int j = i; j > 0; j--)
	{
	    int p = (j - 1) / 2;
	    if (a[j] > a[p])
	    {
		int temp = a[j];
		a[j] = a[p];
		a[p] = temp;
	    }
	}     
	int tmp = a[i];
	a[i] = a[0];
	a[0] = tmp;
    }
}
int main()
{
    int a[200],i=0;
    srand(i);
    for(int j=0;j<200;j++)
    {
        a[j]=rand()%5000;
        i++;
    }
    HeapSort(a)
    for(int j=0;j<200;j++)
        cout<<a[j]<<" ";
}

三.快速排序

快速排序是用的比较多的排序方法之一，顾名思义，它的排序比较快，耗时相对较短。快排的最重要的就是随机寻找每次使用的pivot（支点或枢轴），每一次都选取一个支点，将当前范围内的数进行交换，使得左边的数比支点小，右边的数比支点大，然后分别对支点左边和右边的数组分别进行类似操作，直到所有的数都被排序好。

代码：

#include<iostream>
#include<ctime>
using namespace std;
void QuickSort(int a[200],int head,int tail)
{
    int m = head, n = tail;
    int j = head + rand() % (tail - head + 1);
    while (head < tail)
    {
	if (a[head] == a[tail] && (j == head || j == tail))
	{
	    head++;
	}
	while (head < tail&&a[j] < a[tail])
	{
	    if (a[tail] >= a[j])tail--;
	}
	while (head<tail&&a[j]>a[head])
	{
	    if (a[head] <= a[j])head++;
	}
	if (head == j)j = tail;
	else if (tail == j)j = head;
	int temp = a[head];
	a[head] = a[tail];
	a[tail] = temp;
    }
    if (m < n)
    {
	if(m<j-1)
	QuickSort(a, m, j - 1);
	if(j+1<n)
	QuickSort(a, j + 1, n);
    }
}
int main()
{
    int a[200],i=0;
    srand(i);
    for(int j=0;j<200;j++)
    {
        a[j]=rand()%5000;
        i++;
    }
    HeapSort(a)
    for(int j=0;j<200;j++)
        cout<<a[j]<<" ";
}

四.归并排序

对于归并，这里讲的是2-路归并排序。归并排序主要思想是将数组通过递归的方式，每一次都进行二等分，最后每一份都只剩下了一个元素，然后在将每一次的元素按顺序重新组合起来，这样的话最后所获得的的结果就是已排好序的数组。

对于归并排序，它的排序比较稳定，但是，由于每次重组时都需要额外的空间，所以它的空间复杂度比较大。

代码：

#include<iostream>
#include<ctime>
using namespace std;
void MergeSort(int a[200],int length,int s,int e)
{
    int length1 = 0, length2 = 0;
    length1 = (length + 1) / 2;
    length2 = length - length1;
    int s1 = 0, s2 = 0, e1 = 0, e2 = 0;
    s1 = s;
    s2 = s + length1;
    e1 = s2 - 1;
    e2 = e;
    if(length1>1)
	MergeSort(a, length1, s1, e1);
    if (length2>1)
	MergeSort(a, length2, s2, e2);
    int *a1, *a2;
    a1 = new int[length1];
    a2 = new int[length2];
    for (int i = s1, j = 0; i <= e1; i++, j++)
	a1[j] = a[i];
    for (int i = s2,j = 0; i <= e2; i++, j++)
	a2[j] = a[i];
    int m=s,p=0,q=0;
    while (m<=e&&p<length1&&q<length2)
    {
	if (a1[p] <= a2[q])
	{
            a[m] = a1[p];
	    p++;
	    m++;
	}
	else if (a1[p] > a2[q])
	{
	    a[m] = a2[q];
	    q++;
	    m++;
	}
    }
    if (p < length1)
	for (;p<length1;p++,m++)
	    a[m] = a1[p];
    if (q < length2)
	for (; q < length2; q++, m++)
	    a[m] = a2[q];
}
int main()
{
    int a[200],i=0;
    srand(i);
    for(int j=0;j<200;j++)
    {
        a[j]=rand()%5000;
        i++;
    }
    HeapSort(a)
    for(int j=0;j<200;j++)
        cout<<a[j]<<" ";
}

博主是第一次写博客，所以如果有什么不足的地方请大家多多包涵