冒泡排序、简单选择排序、直接插入排序、希尔排序

冒泡排序（Bubble Sort）的基本思想：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。时间复杂度为O（n²）.

简单选择排序（Simple Selection Sort）的基本思想：通过n-i次关键字之间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i个记录交换。应该说，尽管与冒泡排序同为O(n²)， 但简单选择排序的性能上还是要略优于冒泡排序。

直接插入排序（Straight Insertion Sort）的基本思想：将一个记录插入到前面已经排序好的有序表中，从而得到一个新的、记录数不断加1的有序表。直接插入排序法的时间复杂度为O(n2) 。从这里也看出，同样的O(n²)时间复杂度，直接插入排序法比冒炮和简单选择排序的性能要好一些。

希尔排序（Shell Sort）的基本思想：将相隔某个增量的记录组成一个子序列，在这些子序列内分别进行直接插入排序，得到基本有序的序列，最后在将增量为1的记录（即整个序列）的进行一次直接插入排序。其实希尔排序就是直接插入排序的改进。大量的研究表明，当增量序列为dlta[k]=2^t-k+1-1 ( 0 <=k<=t <= [log₂ (n+l)])时，可以获得不错的效率， 其时间复杂度为O(n^3/2，要好于直接排序的o(n²)。需要注意的是， 增量序列的最后一个增量值必须等于1 才行。另外由于记录是跳跃式的移动，使得排序的效率提高，但也使得希尔排序并不是一种稳定的排序算法。

堆排序(Heap Sort) 的基本思想是：将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根结点。将官移走(其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值) .然后将剩余的n - 1 个序列重新构造成一个堆，这样就刽寻到n 个元素中的次小值。如此反复执行， 便能得到一个有序序列了。其实，堆排序就是对简单选择排序进行的一种改进，这种改进效果是非常明显的。堆排序的时间复杂度是O（nlogn）。由于堆排序对原始记录的排序状态并不敏感，因此它无论是最好、最坏和平均时间复杂度均为O(nlogn) 。这在性能上显然要远远好过于冒泡、简单选择、直接插入的O(n²)的时间复杂度了。

快速排序（Quick Sort）的基本思想是：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行同样的排序，依次递归达到整个序列有序的目的。对于枢轴pivot的选取可以采用三数取中（median of three）法，即取三个关键字先进行排序，将中间作为枢轴，一般是取左端、右端和中间三个数，也可以随机选取。对于待排序列较长的，可采用九数取中的方法。此外，还可以优化一些不必要的交换。优化小数组的排序，即当序列较长时采用快排，较短时采用直接插入排序，设置一个阈值就可以了。快速排序算法经过多次的优化之后，在整体性能上，依旧是排序算法的王者。

归并排序( Merging Sort) 的基本思想是：假设初始序列含有n 个记录， 则可以看成是n 个有序的子序列，每个子序列的长度为1 ，然后两两归并，得到[n/2] <[x]表示不小于x 的最小整数)个长度为2 或1 的有序子序列;再两两归并，……，如此重复， 直至得到一个长度为n 的有序序列为止，这种排序方法称为2 路归并排序.

#include "stdafx.h"

#include "stdio.h" 
#define TRUE 1 
#define FALSE 0
#define MAX_LENGTH_INSERT_SORT 5

void bubblesort(int *list, int index);
void selectsort(int *list, int index);
void insertsort(int *list, int index);
void shellsort(int *list, int index);
void heapsort(int *list, int index);
void heapadjust(int *list, int s, int m);
void quicksort(int *list, int index);
void Qsort(int *list, int low, int high);
int partition(int *list, int low, int high);

typedef int status;
int list[20];    //默认最大长度为20
int temp;
int i, j;
int node;
status change = TRUE;

void swap(int *list, int i, int j)//交换元素
{
    temp = list[i];
    list[i] = list[j];
    list[j] = temp;
}

void main(void)
{
    int index = 0;
    printf("Please input the value you want to sort(exit for 0):
");
    scanf_s("%d", &node);
    while (node != 0)
    {
        list[index] = node;
        index += 1;
        scanf_s("%d", &node);
    }
    //bubblesort(list, index);
    //selectsort(list, index);
    //insertsort(list, index);
    //shellsort(list, index);//wrong
    //heapsort(list, index);
    quicksort(list, index);
}

void bubblesort(int *list, int index) //冒泡排序 时间复杂度O（n2）
{
    for (j = 0; j<index && change; j++)
    {
        change = FALSE;
        for (i = 1; i<index - j; i++)
        {
            if (list[i - 1]>list[i])
            {
                swap(list, i - 1, i);
                change = TRUE;
            }
        }
    }
    printf("
冒泡排序后为：    ");
    for (i = 0; i < index; i++)
    {
        printf("%d ", list[i]);
    }

}

void selectsort(int *list, int index)//简单选择排序  时间复杂度O（n2）
{
    int min;
    for (i = 0; i < index - 1; i++)
    {
        min = i;
        for (j = i + 1; j < index; j++)
        {
            if (list[min]>list[j])
            {
                min = j;
            }
        }
        if (min != i)
        {
            swap(list, min, i);
        }
    }
    printf("
简单选择排序后为：");
    for (i = 0; i < index; i++)
    {
        printf("%d ", list[i]);
    }
}

void insertsort(int *list, int index)//直接插入排序  时间复杂度O（n2）
{
    for (i = 1; i < index; i++)
    {
        if (list[i - 1]>list[i])
        {
            temp = list[i];
            for (j = i; j >= 1 && list[j - 1] > temp; j--)
            {
                list[j] = list[j - 1];
            }
            list[j] = temp;
        }
    }
    printf("
直接插入排序后为：");
    for (i = 0; i < index; i++)
    {
        printf("%d ", list[i]);
    }
}
void shellsort(int *list, int index)   //希尔排序  时间复杂度为O（nr），（1<r<2）
{
    int length = index;
    while (length>1)
    {
        length = length / 3 + 1;       //间隔长度
        for (i = length; i < length; i++)
        {
            if (list[i] < list[i - length])
            {
                temp = list[i];
                for (j = i - length; j >= 0 && list[j]>temp; j -= length)
                {
                    list[j + length] = list[j];      //这一行的j比下一行的j大length
                }
                list[j + length] = temp;            //这一行的j比上一行的j小length
            }
        }
    }
    printf("
希尔排序后为：    ");
    for (i = 0; i < index; i++)
    {
        printf("%d ", list[i]);
    }
}

void heapsort(int *list, int index)//堆排序  时间复杂度为O（nlogn）  不稳定排序
{
    for (i = index / 2; i>0; i--)
    {
        heapadjust(list, i, index);
    }
    for (i = index; i > 1; i--)
    {
        swap(list, 0, i - 1);
        heapadjust(list, 1, i - 1);
    }
    printf("
堆排序后为：      ");
    for (i = 0; i < index; i++)
    {
        printf("%d ", list[i]);
    }
}

void heapadjust(int *list, int s, int m)   //生成大顶堆
{
    temp = list[s - 1];                     //数组list是从0开始，而堆是从1开始，所以要减1；
    for (j = 2 * s; j <= m; j *= 2)
    {
        if (j < m && list[j - 1] < list[j])  //比较结点左孩子和右孩子的大小
            ++j;
        if (temp >= list[j - 1])     //比较孩子中的较大者和结点的大小
            break;
        list[s - 1] = list[j - 1];    //交换
        s = j;
    }
    list[s - 1] = temp;//插入；
}

void quicksort(int *list, int index)//快速排序，冒泡排序的升级版 时间复杂度O(nlogn)
{
    Qsort(list, 0, index - 1);
    printf("
快速排序后为：    ");
    for (i = 0; i < index; i++)
    {
        printf("%d ", list[i]);
    }
}
void Qsort(int *list, int low, int high)
{
    int pivot;
    if (low < high)//if((high-low)>MAX_LENGTH_INSERT_SORT),优化，当high-low大于某个常数时用快速排序
    {
        pivot = partition(list, low, high);

        Qsort(list, low, pivot - 1);
        Qsort(list, pivot + 1, high);
    }
    //else
    //insertsort(list, high-low);
}
int partition(int *list, int low, int high)
{
    int pivotkey;

    int m = low + (high - low) / 2;//三数取中法  ，对于较大的待排序列可使用九数取中
    if (list[low] > list[high])
    {
        swap(list, low, high);
    }
    if (list[m] > list[high])//交换中间和右端，保证中间较小
    {
        swap(list, m, high);
    }
    if (list[m] > list[low])//交换中间和左端，保证中间值放在low位置
    {
        swap(list, m, low);
    }

    pivotkey = list[low];
    while (low < high)
    {
        while (low < high&&list[high] >= pivotkey)
        {
            high--;
        }
        list[low] = list[high];   //采用替换而不交换，减少不必要的交换        swap(list, low, high);
        while (low < high&&list[low] <= pivotkey)
        {
            low++;
        }
        list[high] = list[low];  //采用替换而不交换，减少不必要的交换 swap(list, low, high);

    }
    list[low] = pivotkey;
    return low;

}