Fastest alphabetical list sort given the following limitations: Your function must have an input that takes in an array containing 10000 random names, and must sort these names in alphabetical order. Names have a random length of up to 128 characters. ISO/IEC 8859-1 character set assumed to be used for the list of names.

Usable list of names can be found at http://www.opensourcecf.com/1/2009/05/10000-Random-Names-Database.cfm (firstNameFirst column).

You may not use any native sorting functions available to your language.

The winner will be based purely on speed.

Language used must be compilable/runnable on a standard *nix box.
C - B-tree sort
This sorts randomNames.csv in about 5.8ms on my Core 2 T5500 @ 1.66GHz.  My testing utility is here.
It isn't the fastest algorithm for sorting this quantity of data, but I didn't feel like trieing.
#include &lt;assert.h&gt;
#include &lt;stdbool.h&gt;
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;

typedef struct Btree Btree;

static void btree_insert(Btree **btree, const char *key);
static void btree_emit_and_free(Btree *btree, const char ***out);

void sort(const char **strings, size_t count, const char **out)
{
    size_t i;
    Btree *tree = NULL;
    const char **out_start = out;
    
    for (i = 0; i &lt; count; i++)
        btree_insert(&amp;tree, strings[i]);
    
    btree_emit_and_free(tree, &amp;out);
    
    assert(out - out_start == (ssize_t) count);
}

/*
 * Maximum (U) and minimum (L) number of *keys* per B-tree node.
 *
 * The maximum number of *branches* a B-tree may have is U+1 :
 *
 *       KEY   KEY
 *     /     |     \
 * branch  branch  branch
 */
#define U 20
#define L (U / 2)

struct Btree {
    /* Number of keys (rather than branches). */
    unsigned char count;
    
    /* 0 if node is a leaf, 1 if it has leaf children, etc. */
    unsigned char depth;
    
    const char *keys[U];
    
    /* Allocated to U+1 items if this is an internal node. */
    Btree *branches[];
};

static Btree *allocLeaf(void)
{
    return malloc(sizeof(Btree));
}

static Btree *allocInternal(void)
{
    return malloc(sizeof(Btree) + (U+1) * sizeof(Btree *));
}

static bool insert(Btree *node, const char *x,
                   const char **new_x, Btree **new_xr);
static bool insert_item(Btree *node, unsigned int k,
                        const char  *x,     Btree  *xr,
                        const char **new_x, Btree **new_xr);
static unsigned int
find_insertion_point(const char *keys[], unsigned int count, const char *x);

static void btree_insert(Btree **btree, const char *key)
{
    if (*btree == NULL) {
        Btree *root = allocLeaf();
        root-&gt;count = 1;
        root-&gt;depth = 0;
        root-&gt;keys[0] = key;
        *btree = root;
    } else {
        const char *new_x;
        Btree *new_xr;
        
        if (insert(*btree, key, &amp;new_x, &amp;new_xr)) {
            Btree *root = allocInternal();
            root-&gt;count = 1;
            root-&gt;depth = (*btree)-&gt;depth + 1;
            root-&gt;keys[0] = new_x;
            root-&gt;branches[0] = *btree;
            root-&gt;branches[1] = new_xr;
            *btree = root;
        }
    }
}

static bool insert(Btree *node, const char *x,
                   const char **new_x, Btree **new_xr)
{
    unsigned int k = find_insertion_point(node-&gt;keys, node-&gt;count, x);
    Btree *xr;
    
    if (node-&gt;depth == 0)
        xr = NULL;
    else if (insert(node-&gt;branches[k], x, new_x, new_xr))
        x = *new_x, xr = *new_xr;
    else
        return false;
    
    return insert_item(node, k, x, xr, new_x, new_xr);
}

static bool insert_item(Btree *node, unsigned int k,
                        const char  *x,     Btree  *xr,
                        const char **new_x, Btree **new_xr)
{
    unsigned int i;
    bool internal = xr != NULL;
    
    if (node-&gt;count &lt; U) {
        /* Enough case */
        for (i = node-&gt;count; i-- &gt; k;)
            node-&gt;keys[i + 1] = node-&gt;keys[i];
        node-&gt;keys[k] = x;
        if (internal) {
            for (i = node-&gt;count + 1; i-- &gt; k + 1;)
                node-&gt;branches[i + 1] = node-&gt;branches[i];
            node-&gt;branches[k + 1] = xr;
        }
        node-&gt;count++;
        return false;
    } else {
        Btree *r = internal ? allocInternal() : allocLeaf();
        
        node-&gt;count = L;
        r-&gt;count = L;
        r-&gt;depth = node-&gt;depth;
        
        if (k &lt; L) {
            /* Left case */
            *new_x = node-&gt;keys[L - 1];
            for (i = 0; i &lt; L; i++)
                r-&gt;keys[i] = node-&gt;keys[i + L];
            for (i = L - 1; i-- &gt; k;)
                node-&gt;keys[i + 1] = node-&gt;keys[i];
            node-&gt;keys[k] = x;
            if (internal) {
                for (i = 0; i &lt;= L; i++)
                    r-&gt;branches[i] = node-&gt;branches[i + L];
                for (i = L; i-- &gt; k + 1;)
                    node-&gt;branches[i + 1] = node-&gt;branches[i];
                node-&gt;branches[k + 1] = xr;
            }
        } else if (k == L) {
            /* Central case */
            *new_x = x;
            for (i = 0; i &lt; L; i++)
                r-&gt;keys[i] = node-&gt;keys[i + L];
            if (internal) {
                r-&gt;branches[0] = xr;
                for (i = 1; i &lt;= L; i++)
                    r-&gt;branches[i] = node-&gt;branches[i + L];
            }
        } else {
            /* Right case */
            *new_x = node-&gt;keys[L];
            for (i = 0; i &lt; k - L - 1; i++)
                r-&gt;keys[i] = node-&gt;keys[i + L + 1];
            r-&gt;keys[k - L - 1] = x;
            for (i = k - L; i &lt; L; i++)
                r-&gt;keys[i] = node-&gt;keys[i + L];
            if (internal) {
                for (i = 0; i &lt; k - L; i++)
                    r-&gt;branches[i] = node-&gt;branches[i + L + 1];
                r-&gt;branches[k - L] = xr;
                for (i = k - L + 1; i &lt;= L; i++)
                    r-&gt;branches[i] = node-&gt;branches[i + L];
            }
        }
        
        *new_xr = r;
        return true;
    }
}

static unsigned int
find_insertion_point(const char *keys[], unsigned int count, const char *x)
{
    unsigned int start = 0;
    unsigned int middle;
    
    while (count) {
        middle = count &gt;&gt; 1;
        if (strcmp(x, keys[start + middle]) &lt; 0) {
            count = middle;
        } else {
            start += middle + 1;
            count -= middle + 1;
        }
    }
    
    return start;
}

static void btree_emit_and_free(Btree *btree, const char ***out)
{
    unsigned int i;
    
    if (btree-&gt;depth == 0) {
        for (i = 0; i &lt; btree-&gt;count; i++)
            *(*out)++ = btree-&gt;keys[i];
    } else {
        for (i = 0; i &lt; btree-&gt;count; i++) {
            btree_emit_and_free(btree-&gt;branches[i], out);
            *(*out)++ = btree-&gt;keys[i];
        }
        btree_emit_and_free(btree-&gt;branches[btree-&gt;count], out);
    }
    
    free(btree);
}