常用排序算法

选择排序 Selection sort

每次从尚未排好的数组范围里选出一个最小的放到正确的位置。

void selection_sort(int array[], int size)
{
    int lhs, rhs;
    int min;

    for (lhs = 0; lhs < size - 1; lhs++) {
        min = lhs;
        for (rhs = lhs + 1; rhs < size; rhs++) {
            if (array[rhs] < array[min])
                min = rhs;
        }
        swap(array, lhs, min);
    }
}

快速排序 Quicksort

从数组里选出一个基准元素，通过交换位置让它前面的元素都比它小、后面的元素都比它大，最后分而治之。

void quicksort(int array[], int left, int right)
{
    if (left < right) {
        int pivit = right; // lazy :(
        int store = left;
        int i;

        for (i = left; i < right; i++) {
            if (array[i] < array[pivit]) {
                swap(array, i, store);
                store++;
            }
        }
        swap(array, store, pivit);

        quicksort(array, left, store - 1);
        quicksort(array, store + 1, right);
    }
}

插入排序 Insertion sort

每次从尚未排好的数组范围取出一个元素，放到已排好的数组范围中的正确位置。（现实生活中排序时一般用的就是类似这种算法）

void insertion_sort(int array[], int size)
{
    int lhs, rhs;
    int cur;

    for (rhs = 1; rhs < size; rhs++) {
        cur = array[rhs];
        for (lhs = rhs - 1; (lhs > 0) && (array[lhs] > cur); lhs--)
            array[lhs + 1] = array[lhs];
        array[lhs] = cur;
    }
}

堆排序 Heapsort

保持未排数组为堆积树，每次摘取根结点，即可取出当前未排范围中的最大/最小值放入正确位置。

void sift_down(int heap[], int root, int end)
{
    int l_child = root * 2 + 1;
    int r_child = root * 2 + 2;
    int max = root; // max heap

    if (l_child <= end && heap[l_child] > heap[max])
        max = l_child;

    if (r_child <= end && heap[r_child] > heap[max])
        max = r_child;

    if (max != root) {
        swap(heap, max, root);
        sift_down(heap, max, end);
    }
}

void heapsort(int array[], int size)
{
    int i;

    // from last parent node
    for (i = (size - 2) / 2; i >= 0; i--)
        sift_down(array, i, size - 1);

    for (i = size - 1; i > 0; i--) {
        swap(array, 0, i);
        sift_down(array, 0, i - 1);
    }
}

嗯，基本上常用的就是这些啦~

什么，没有冒泡排序？好吧，我至今都想不明白像冒泡排序这样写起来没有选择排序方便、想起来没有插入排序方便