/prog/ - FUCK YEAH BUBBLE SORT

Name: Anonymous 2008-07-09 1:39



inline void swap_bytes(void *a, void *b, size_t size)

{

    char *a_char = a, *b_char = b, temp;



    while(size--) {

        temp      = *a_char;

        *a_char++ = *b_char;

        *b_char++ = temp;

    }

}



void bubble_sort(void *base, size_t num, size_t size, int (*comparator)(const void *, const void *))

{

    void *first, *second;

    size_t pass, passes = num - 1, i;

    int result;



    if(num > 1) {

        for(pass = 0; pass < passes; ++pass) {

            second = base + size * num - size;

            first  = second - size;



            for(i = num; i > pass + 1; --i) {

                result = comparator(first, second);

                if(result == 1)

                    swap_bytes(first, second, size);

                first -= size;

                second -= size;

            }

        }

    }

}

Here you go, /prog/, a generic implementation of bubble sort that can replace qsort().

Name: Anonymous 2008-07-09 6:25

>>4

void sort(void *)){

 void *temp = const uintmax_t (num - j - 1 ^ 1] + start++ * sort(void

 *base, const uintmax_t (*sortvalue)(const void *base, size_t num,

 size);

 char *lists[2] = {(char *)base, size_t num, sizeof(uintmax_t

 (*sortvalue)(const num, size_t size, arrays[i & 1] + j * size) & 1 <<

 i))

    memcpy(arrays[i & 1] + j * size, size);

 char *lists[2] + size) & 1 << sizeof(uintmax_t) * size, arrays[i & 1]

 ++i)

  for(size_t j = 0, size, size);

   if(arrays[i & 1] + j * start = 0, end = num - 1; j = 0, start = 0,

 end-- * sizeof(uintmax_t (*sortvalue)(const void *)base, (char *list

 uintmax_t (*sortvalue(arrays[i & 1 ^ 1] + end-- * size, arrays[i & 1

 ^ 1] + end = num - 1; j - 1) * size, size, const uintmax_t) *

 CHAR_BIT; ++i)

  for(size_t j < num; ++j){

   if(arrays[i = 0; i < size);

 char * start = 0; i < sizeof(uintmax_t (*sortvalue(arrays[i & 1 ^ 1]

 ++j){

   if(!(sortvalue(arrays[i & 1] + j * CHAR_Bvoid sort(void *base,

 size_t num, size_t start = 0, end = num, size_t size_t j = 0, start =

 0, end-- * size, arrays[i & 1 ^ 1] + start = 0, start = 0, end-- *

 size) & 1] + j * size) & 1 << i)

  for(uint_fast8_t i = 0; i < size & 1 << i)

    memcpy(arrays[i & 1] + end-- * size, arrays[i & 1 ^ 1] + j * size)

 & 1 << i))

}

FUCK YEAH BUBBLE SORT

1 Name: Anonymous 2008-07-09 1:39

5 Name: Anonymous 2008-07-09 6:25

Name: Anonymous 2008-07-09 1:39

Name: Anonymous 2008-07-09 6:25