算法导论之插入排序，选择排序，归并排序，冒泡排序，希尔排序，堆排序，快速排序的c语言实现

另外还有基数排序，计数排序，桶排序等，暂时没有时间看。先把上面这些的c语言代码写一下，并且简略提一下原理。

插入排序：对于未排序的数据，在已排序数据中从后向前扫描，找到相应位置插入.(第一个元素当做已排序）扫描过程中需要反复把已排序的元素逐步向后移动，为新元素提供插入空间。

void insertion_sort(int *a, int len)        //调用insertion_sort(a, len)
{
    int i, j, key;                            //key是待排序数
    for (i = 1; i < len; ++i)
    {
        key = a[i];
        j = i - 1;
        while (j >= 0 && key < a[j])        //逐个后移
        {
            a[j+1] = a[j];
            --j;
        }
        a[j+1] = key;
    }
}

选择排序：首先找到数组a中最小元素与a【1】交换，再次小元素与a【2】交换，对a中前n-1个元素继续此过程。

void selection_sort(int *a, int len)        //调用selection_sort(a, len)
{
    int i, j, k, t;
    for (i = 0; i < len - 1; ++i)
    {
        k = i;
        for (j = i + 1; j < len; ++j)
            if (a[k] > a[j])
                k = j;
        t = a[i];
        a[i] = a[k];
        a[k] = t;
    }
}

归并排序：

void merge(int *a, int *temp_array, int lpos, int rpos, int right_end)
{
    int i, left_end, num_element, tmp_pos;
    left_end = rpos - 1;    
    tmp_pos = lpos;
    num_element = right_end - lpos + 1;
    while (lpos <= left_end && rpos <= right_end)
    {
        if (a[lpos] <= a[rpos])
            temp_array[tmp_pos++] = a[lpos++];
        else
            temp_array[tmp_pos++] = a[lpos++];
    }
    while (lpos <= left_end)
        temp_array[tmp_pos++] = a[lpos++];
    while (rpos <= right_end)
        temp_array[tmp_pos++] = a[rpos++];
    for (i = 0; i < num_element; ++i, right_end--)
        a[right_end] = temp_array[right_end];
}
void merge_sort(int *a, int *temp_array, int left, int right) //调用merge_sort(a, t, 0, len - 1)
{
    int mid;
    if (left < right)
    {
        mid = (left + right) / 2;
        merge_sort(a, temp_array, left, mid);
        merge_sort(a, temp_array, mid + 1, right);
        merge(a, temp_array, left, mid + 1, right);
    }
}

冒泡排序：重复交换相邻的两个反序元素。

void bubble_sort(int *a, int len)
{
    int i, j, t;
    for (i = 0; i < len; ++i)
        for (j = len - 1; j > i; --j)
            if (a[j] < a[j-1])
            {
                t = a[j];
                a[j] = a[j-1];
                a[j-1] = t;
            }
}

希尔排序（shell）：缩小增量排序，将待排序列划分为若干个较小的序列，分别进行直接插入排序，是需要排序的数列基本有序，最后再用依稀直接插入排序。一般取上一增量的一半作为此次划分的增量，直到增量为1.

void shell_sort(int *a, int len)
{
    int gap, i, j, t;
    for (gap = len / 2; gap > 0; gap /= 2)
        for (i = gap; i < len; ++i)
            for (j = i - gap; j >=0 && a[j] > a[j+gap]; j -= gap)
            {
                t = a[j];    a[j] = a[j+gap];    a[j+gap] = t;
            }
}

堆排序：

void swap(int *a, int *b)
{
    int t = *a;    *a = *b; *b = t;
}
void max_heapify(int *a, int i, int heapsize)
{
    int l = 2 * i + 1;
    int r = 2 * i + 2;
    int largest;
    if (l <= heapsize - 1 && a[l] > a[i])
        largest = l;
    else
        largest = i;
    if (r <= heapsize - 1 && a[r] > a[i])
        largest = r;
    if (largest != i)
    {
        swap(&a[i], &a[largest]);
        max_heapify(a, largest, heapsize);
    }
}
void build_max_heap(int *a, int heapsize)
{
    int i;
    for (i = heapsize / 2 - 1; i >= 0; --i)
        max_heapify(a, largest, heapsize);
}
void heap_sort(int *a, int len)
{
    int i;
    build_max_heap(a, len);
    for (i = len - 1; i >= 1; --i)
    {
        swap(&a[0], &a[i]);
        max_heapify(a, 0, i);
    }
}

 快速排序：

void swap(int *a, int *b)
{
    int t = *x; *x = *y; *y = t;
}
int partition(int *a, int p, int r)
{
    int x = a[r];
    int i = p - 1;
    int j;
    for (j = 0; j <= r - 1; ++j)
    {
        if (a[j] <= x)
        {
            ++i;
            swap(&a[i], &a[j]);
        }
    }
    swap(&a[i+1], &a[r]);
    return i + 1;
}
void quick_sort(int *a, int p, int r)        //调用(a, 0, len - 1)
{
    if (p < r)
    {
        int q = partition(a, p, r);
        quick_sort(a, p, q - 1);
        quick_sort(a, q + 1, r);
    }
}