具有 C 语言基本排序算法的良好参考卡/备忘单？ [关闭]

Question

我一直在寻找完美的参考卡（运气不好），它包含 C 中的所有基本排序算法（或者可能是伪代码）。维基百科是一个极好的信息来源，但这次我正在寻找更便携的东西（如果可能的话，口袋大小）当然是可打印的。任何建议将不胜感激！

Answer 1

您需要一本 Robert Sedgewick 的《C 语言算法》一书。

http://www.amazon.com/Algorithms-C-paperback-Robert-Sedgewick/dp/0768682339/

我可能会找一个用过的。新的有点贵（但仍然完全值得。）

Answer 2

试试圣经：

http://dannyreviews.com/h/Art_Programming.html

Answer 3

您绝对应该查看Animated Sorting Algorithms 页面。它是排序算法的绝佳资源。

编辑感谢 Peterino 提供新链接！

Answer 4

一般来说，人们不太担心不同的算法，很多人使用标准库qsort() 函数（它可能实际使用也可能不使用快速排序）进行排序。当他们不使用它时，他们通常有更复杂的要求。这可能是因为他们需要进行外部排序（将数据溢出到磁盘），或者出于与性能相关的原因。有时，与使用qsort()（或者，实际上是bsearch()）相关的函数调用的感知开销太大了。有时，人们不想冒 Quicksort 潜在的 O(N^2) 最坏情况行为的风险，但大多数生产 qsort() 算法会为您避免这种情况。

除了各种关于算法的书籍 - Sedgewick 就是其中之一，但还有很多其他书籍 - 您还可以看看 Jon Bentley 的“Programming Pearls”或“More Programming Pearls”书籍。无论如何，这会很好——它们非常好——但是“更多编程珍珠”还包括一个用 awk 编写的简单算法库，包括插入排序、堆排序和快速排序。它错过了冒泡排序、壳排序和 BogoSort。它也不包括基数排序。

Answer 5

我为我的一个学习 C 的朋友做的，也许你会发现它有帮助：

#include <stdlib.h>
#include <string.h>

static void swap(int *a, int *b) {
    if (a != b) {
        int c = *a;
        *a = *b;
        *b = c;
    }
}

void bubblesort(int *a, int l) {
    int i, j;

    for (i = l - 2; i >= 0; i--)
        for (j = i; j < l - 1 && a[j] > a[j + 1]; j++)
            swap(a + j, a + j + 1);
}

void selectionsort(int *a, int l) {
    int i, j, k;
    for (i = 0; i < l; i++) {
        for (j = (k = i) + 1; j < l; j++)
            if (a[j] < a[k])
                k = j;
        swap(a + i, a + k);
    }
}

static void hsort_helper(int *a, int i, int l) {
    int j;

    for (j = 2 * i + 1; j < l; i = j, j = 2 * j + 1)
        if (a[i] < a[j])
            if (j + 1 < l && a[j] < a[j + 1])
                swap(a + i, a + ++j);
            else
                swap(a + i, a + j);
        else if (j + 1 < l && a[i] < a[j + 1])
            swap(a + i, a + ++j);
        else
            break;
}

void heapsort(int *a, int l) {
    int i;

    for (i = (l - 2) / 2; i >= 0; i--)
        hsort_helper(a, i, l);

    while (l-- > 0) {
        swap(a, a + l);
        hsort_helper(a, 0, l);
    }
}

static void msort_helper(int *a, int *b, int l) {
    int i, j, k, m;

    switch (l) {
        case 1:
            a[0] = b[0];
        case 0:
            return;
    }

    m = l / 2;
    msort_helper(b, a, m);
    msort_helper(b + m, a + m, l - m);
    for (i = 0, j = 0, k = m; i < l; i++)
        a[i] = b[j < m && !(k < l && b[j] > b[k]) ? j++ : k++];
}

void mergesort(int *a, int l) {
    int *b;

    if (l < 0)
        return;

    b = malloc(l * sizeof(int));
    memcpy(b, a, l * sizeof(int));
    msort_helper(a, b, l);
    free(b);
}

static int pivot(int *a, int l) {
    int i, j;

    for (i = j = 1; i < l; i++)
        if (a[i] <= a[0])
            swap(a + i, a + j++);

    swap(a, a + j - 1);

    return j;
}

void quicksort(int *a, int l) {
    int m;

    if (l <= 1)
        return;

    m = pivot(a, l);
    quicksort(a, m - 1);
    quicksort(a + m, l - m);
}

struct node {
    int value;
    struct node *left, *right;
};

void btreesort(int *a, int l) {
    int i;
    struct node *root = NULL, **ptr;

    for (i = 0; i < l; i++) {
        for (ptr = &root; *ptr;)
            ptr = a[i] < (*ptr)->value ? &(*ptr)->left : &(*ptr)->right;
        *ptr = malloc(sizeof(struct node));
        **ptr = (struct node){.value = a[i]};
    }

    for (i = 0; i < l; i++) {
        struct node *node;
        for (ptr = &root; (*ptr)->left; ptr = &(*ptr)->left);
        a[i] = (*ptr)->value;
        node = (*ptr)->right;
        free(*ptr);
        (*ptr) = node;
    }
}