qsortrandom_shuffle

1，实现random_shuffle：random_shuffle是STL中的一个模板算法，作用是随机重排列一对random access iterator之间的元素。基本思想是：假设序列有n个元素，先从所有元素中选一个放到位置1（即与位置1的元素交换），然后再从剩下的n-1个元素中选择一个放到位置2，以此类推。

2，qsort：partition之后双向递归。

qsort的实现：

#include <string.h> /* memcpy */

#define SWAP_ELEM(pl, pr, size) do {\
    char temp[size]; /* C99 */      \
    memcpy(temp, pl, size); \
    memcpy(pl, pr, size);   \
    memcpy(pr, temp, size); \
} while (0)

char *partition(char *pl, char *pr, size_t size, int pivot_index,
        int (*compare_func)(const void*, const void*))
{
    char *pivot;
    char *next_less; // pointer to the next slot for elements
                    // with value less than the pivot.

    // 1, swap the pivot element to the last slot.
    pivot = pl + size * pivot_index;
    SWAP_ELEM(pr, pivot, size);
    pivot = pr;
    // 2, move elements with value less than pivot to the front of the sequence.
    next_less = pl;
    while (pl < pr) {
        if (compare_func(pl, pivot) < 0) {
            SWAP_ELEM(pl, next_less, size);
            next_less += size;
        }
        pl += size;
    }
    // 3, swap the pivot to its place
    SWAP_ELEM(next_less, pivot, size);
    return next_less;
}

void do_my_qsort(char *pl, char *pr, size_t size, 
        int(*compare_func)(const void *, const void *))
{
    if (pr <= pl) { // 0 or 1 element
        return;
    }

    if (pr - pl == size) { // 2 elements
        if (compare_func(pl, pr) > 0)
            SWAP_ELEM(pl, pr, size);
        return;
    }

    // more than 2 elements, divide & conquer.
    // 1, partition the sequence, pivot is chosen to be the leftmost element.
    char *new_pivot = partition(pl, pr, size, 0, compare_func);
    // 2, recursively enter two subsequences.
    do_my_qsort(pl, new_pivot - size, size, compare_func);
    do_my_qsort(new_pivot + size, pr, size, compare_func);
}

/* Implementation of libc-qsort. */
void my_qsort(void *base, size_t nmemb, size_t size,
        int(*compare_func)(const void *, const void *))
{
    char *pbase = base;
    char *plast = base + nmemb * size - size; // start addr of the last element.

    do_my_qsort(pbase, plast, size, compare_func);
}

#undef SWAP_ELEM

qsort的测试：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <assert.h>

void my_qsort(void *base, size_t nmemb, size_t size,
        int(*compare_func)(const void *, const void *));

#define MAX_N   27
int arr[MAX_N];

void print_arr(void)
{
    int i;

    for (i = 0; i < MAX_N; i++)
        printf("%d ", arr[i]);
    printf("\n");
}

/* A simplified version of the STL algorithm random_shuffle */
void my_random_shuffle(int *arr, int n)
{
    int i;

    srand(time(0));
    for (i = 1; i < n; i++) {
        int selected_index = rand() % (i + 1); // OK, forgive my using rand(),
                                        //which is of limited random digits.
        int temp = arr[selected_index]; // swap to current position.
        arr[selected_index] = arr[i];
        arr[i] = temp;
    }
    /* equivalent to:
    for (i = n - 1; i > 0; i--) {
        int selected_index = rand() % (i + 1); // select a random element.
        int temp = arr[selected_index]; // swap to current position.
        arr[selected_index] = arr[i];
        arr[i] = temp;
    }
    */
}

int comp(const void *lhs, const void *rhs)
{
    return *(int *)lhs - *(int *)rhs;
}

int main(int argc, char *argv[])
{
    int i;

    for (i = 0; i < MAX_N; i++)
        arr[i] = MAX_N - 1 - i;
// case #1, sequence of 1 element
    printf("case #1: \n");
    my_qsort(arr, 1, sizeof(arr[0]), comp);
    print_arr();
// case #2, sequence of 2 elements
    printf("case #2: \n");
    my_qsort(arr, 2, sizeof(arr[0]), comp);
    print_arr();
// case #3, sequence of 3 elements
    printf("case #3: \n");
    my_qsort(arr, 3, sizeof(arr[0]), comp);
    print_arr();

// case #4, all 0's
    printf("case #4: \n");
    for (i = 0; i < MAX_N; i++)
        arr[i] = 0;
    my_qsort(arr, MAX_N, sizeof(arr[0]), comp);
    print_arr();

// case #5, ascent sequence.
    printf("case #5: \n");
    for (i = 0; i < MAX_N; i++)
        arr[i] = i;
    my_qsort(arr, MAX_N, sizeof(arr[0]), comp);
    print_arr();

// case #6, descent sequence.
    printf("case #6: \n");
    for (i = 0; i < MAX_N; i++)
        arr[i] = MAX_N - 1 - i;
    my_qsort(arr, MAX_N, sizeof(arr[0]), comp);
    print_arr();

// case #7, random permutated sequence.
    printf("case #7: \n");
    for (i = 0; i < MAX_N; i++)
        arr[i] = i;
    my_random_shuffle(arr, MAX_N);
    print_arr();
    //qsort(arr, MAX_N, sizeof(arr[0]), comp);
    //print_arr();
    my_qsort(arr, MAX_N, sizeof(arr[0]), comp);
    print_arr();

    return 0;
}