六种排序

1. 选择排序

思想：首先记录待排序的第一个元素下标k，然后每一趟从待排序的记录中选择小于data[k]的最小元素，顺序放在已排好序子表的最后，直到全部排序完毕

时间复杂度：O(n^2)

空间复杂度：O(1)

稳定性：不稳定

void selectSort(int data[], int n)
{
    int tmp, k, i, j;
    for (i = 0; i < n - 1; ++i)
    {
        k = i;
        for (j = i + 1; j < n; ++j)
        {
            if (data[j] < data[k])
                k = j;
        }
        if (k != i)//若k=i则证明已经是有序的了
        {
            tmp = data[i];
            data[i] = data[k];
            data[k] = tmp;
        }
    }
}

2. 冒泡排序

思想：将数组头部看成水面，数组尾部看成水底，最小（或最大）的元素上浮（或下沉）直到 结束，采用的是比较元素大小然后交换元素值的思想，每次都选择未排序的 元素中最小或最大元素送达指定的位置。

时间复杂度：最好情况，数组本身是正序的，O(n)；最坏情况，数组是反序的，O(n^2)；平均时间复杂度为O(n^2)

空间复杂度：O(1)

稳定性：稳定

void bubbleSort(int data[], int n)
{
    int i, j, tmp,flag;
    for (i = 0; i < n - 1; ++i)
    {
        flag = 0;
        for (j = 0; j < n - i - 1; ++j)
        {
            if (data[j+1] < data[j])
            {
                tmp = data[j];
                data[j] = data[j + 1];
                data[j + 1] = tmp;
                flag = 1;
            }
        }
        if(flag == 0)
        {   
            return;
        }
    }

}

3. 插入排序

思想：将原序列分为有序区和无序区,初始时data[0]自成一个有序区，每次外部循环将无序区的第一个元素插入到有序区的适 当位置，同时有序区元素加1，无序区元素减1，这样直到无序区的元素为0

时间复杂度：最好情况，初始数组为正序（此处为递增），O(n)；最坏情况，初始数组为反 序，O(n2)；平均时间复杂度为O(n2)

空间复杂度：O(1)

稳定性：稳定。当data[i]=datda[i-1]时，相对位置不变，所以是稳定的排序

void insertSort(int data[], int n)
{
    int i, j, tmp;
    for (i = 1; i < n; ++i)
    {
        tmp = data[i];
        for(j = i - 1; j >= 0 && tmp < data[j]; --j)
        {
            data[j + 1] = data[j];
        }        

        //若j<0则tmp是有序区的最小元素，若tmp>=data[j]则将tmp放在data[j]的
        //后面data[j+1]处
        data[j + 1] = tmp;
    }
}

4. 希尔排序

思想：本质上还是属于插入排序，只不过是先对序列分组，然后组内直接插入，同时，分组数 由多到少，组内元素由少到多，顺序性由差到好，直到最后一步组间距为1时， 直接插入排序的数组已经基本有序了

时间复杂度：O(nlogn)约为O(1.3n)

空间复杂度：O(1)

稳定性：不稳定

void shellSort(int data[], int n)
{
    int i, j, gap;
    int tmp;
    gap = n / 2;
    while (gap > 0)
    {
        //这样记忆，整个for循环其实就是直接插入排序的过程，只不过将直接插入排序
        //的1->gap罢了，最后当gap=1的时候就是直接插入排序了。
        for (i = gap; i < n; i = i + gap)
        {
            tmp = data[i];
            for(j = i - gap; j >= 0 && tmp < data[j]; j = j -gap)
            {
                 data[j + gap] = data[j];
            }
            data[j + gap] = tmp;
        }
        gap = gap / 2;
    }
}

5. 快速排序

思想：分治的思想，将大问题转化为小问题，递归的思想，最重要的过程就是划分，划分结束 了，数组也就排好序了，快速排序是排序算法中非常重要的一种

先从数列中取出一个数作为基准数（枢轴）。分区过程将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。 (升序)再对左右区间重复第二步，直到各区间只有一个数。

时间复杂度：O(nlogn)

稳定性：不稳定

void quickSort(int data[], int start, int end)
{
    int i = start, j = end;
    int pivot;
    if (start < end)
    {
       //每次递归都取无序区的第一个元素作为中心基准，这个地方可以改进为随机的方法
        pivot = data[start];
        while (i != j)
        {
            while (j>i && data[j] > pivot)
                --j;
            data[i] = data[j];
            while (i < j && data[i] < pivot)
                ++i;
            data[j] = data[i];
        }
        data[i] = pivot;
        quickSort(data, start, i - 1);
        quickSort(data, i + 1, end);
    }
}

6. 归并排序

思想：分治的思想，将数组分成二组 A， B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。可以将 A， B 组各自再分成二组。依次类推， 当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序

时间复杂度：O(nlogn)

稳定性：稳定的

void merge(int data[], int low, int mid, int high)
{
	int i = low, j = mid + 1, k = 0;
	//临时存储排好序的数组
	int *tmp = new int[high - low + 1];
	while (i <= mid && j <= high)
	{
		if (data[i] < data[j])
			tmp[k++] = data[i++];
		else
			tmp[k++] = data[j++];
	}
	while (i <= mid)
		tmp[k++] = data[i++];
	while (j <= high)
		tmp[k++] = data[j++];

	for (int i = low, k = 0; i <= high; i++, k++)
		data[i] = tmp[k];
	delete[] tmp;
}
void mergeSortR(int data[], int low, int high)
{
	int mid;
	if (low < high)
	{
		mid = (low + high) / 2;
		mergeSortR(data, low, mid);
		mergeSortR(data, mid + 1, high);
		merge(data, low, mid, high);
	}
}

总结：

插入、冒泡排序的速度较慢，但参加排序的序列局部或整体有序时，这种排序能达到较快的速度。

反而在这种情况下，快速排序反而慢了。

当n较小时，对稳定性不作要求时宜用选择排序，对稳定性有要求时宜用插入或冒泡排序。

若待排序的记录的关键字在一个明显有限范围内时,且空间允许是用桶排序。

当n较大时，关键字元素比较随机，对稳定性没要求宜用快速排序。

当n较大时，关键字元素可能出现本身是有序的，对稳定性有要求时，空间允许的情况下。

宜用归并排序。

当n较大时，关键字元素可能出现本身是有序的，对稳定性没有要求时宜用堆排序。