排序算法C语言实现代码

冒泡排序，选择排序， 归并排序，快速排序，堆排序

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

void display(int *arr, int len);

void bubble_sort(int *unsort, int len) {
    int i, j;
    for (i = 0; i < len; i++) {
        for (j = 1 ; j < len - i ; j++) {
            if (unsort[j - 1] > unsort[j] )
            {
                int tmp;
                tmp = unsort[j];
                unsort[j] = unsort[j -1];
                unsort[j-1] = tmp;
            }
        }
    }
}

void display(int *arr, int len)
{
    int i;
    for (i = 0; i < len; i++) {
        printf("%-4d", arr[i]);
    }

    printf("\n");
}

void select_sort(int *unsort, int len)
{
    int i, j, k;
    for (i = 0; i < len; i++) {
        int tmp;
        k = i;
        for (j = i + 1; j < len; j++) {
            if (unsort[j - 1] < unsort[j]) {
                k = j;
            }
        }
        tmp = unsort[i];
        unsort[i] = unsort[k];
        unsort[k] = tmp;
    }

}    
void merge_sort(int *arr, int p, int q, int r);

void merge(int *arr, int l, int r)
{
    if (l == r) {
        return;
    }
    int pos = (l + r) /2;
    merge(arr, l, pos);
    merge(arr, pos + 1, r);
    merge_sort(arr, l, pos, r);
}

void merge_sort(int *arr, int p, int q, int r)
{
    int *m, *n;
    int i, j;
    int k, l;
    i = q - p + 1;
    j = r - q;
    m = (int *) malloc(i * sizeof(int));
    n = (int *) malloc(i * sizeof(int));
    memcpy(m, arr + p, i * sizeof(int));
    memcpy(n, arr + q + 1, j * sizeof(int));

    k = l = 0;
    while (p <= r) {
        if (k < i && l < j) {
            if (m[k] < n[l]) {
                arr[p++] = m[k++];
            }
            else {
                arr[p++] = n[l++];
            }
        }
        else {
            break;
        }
    }    
    while (k < i) {
        arr[p++] = m[k++];
    }
    while (l < j) {
        arr[p++] = n[l++];
    }
    free(m);
    free(n);
}

int pattern(int *arr, int l ,int r)
{
    int mark = arr[(l + r) / 2];
    
    arr[(l + r) / 2] = arr[l];
    while (l < r) {
        while (l < r && arr[r] < mark ) {
            r--;    
        }
        arr[l++] = arr[r];
        while (l < r && arr[l] > mark ) {
            l++;
        }
        arr[r] = arr[l];
    }
    arr[r] = mark;
    return r;
}


void quick_sort(int *arr, int l, int r)
{
    int k;
    if (l >= r) {
        return;
    }

    k = pattern(arr,  l, r);
    quick_sort(arr, l, k - 1);
    quick_sort(arr, k + 1, r);
}

void adjust_heap(int *arr, int pos, int len);
void create_heap(int *arr, int len)
{
    int i;
    int scope = len / 2;
    while (scope >= 0) {
        adjust_heap(arr, scope--, len);
    }
}

void adjust_heap(int *arr, int pos, int len)
{
    int right, left;
    int k = pos;

    left = 2 * pos;
    right = left + 1;
    
    if (left >= len) {
        return;
    }

    if ( arr[k] < arr[left]) {
        k = left;
    }
    if (right < len && arr[k] < arr[right]) {
        k = right;
    }
    
    if (pos != k) {
        int tmp = arr[k];
        arr[k] = arr[pos];
        arr[pos] = tmp;
        adjust_heap(arr, k, len);
    }    
}
void heap_sort(int *arr, int len)
{
    int tmp;
    create_heap(arr, len);
    while (len > 0) {
        tmp = arr[0];
        arr[0] = arr[len - 1];
        arr[len - 1] = tmp;
        adjust_heap(arr, 0, --len);
    }
}


int main()
{
    int A[] = {5, 12, 2, 3, 7, 3, 24, 12, 11, 23, 1};
    display(A, sizeof(A)/ sizeof(int));

    bubble_sort(A, sizeof(A) / sizeof(int));       // xiao->da        
    display(A, sizeof(A)/ sizeof(int));
    
    select_sort(A, sizeof(A) / sizeof(int));       // da->xiao
    display(A, sizeof(A)/ sizeof(int));
    
    merge(A, 0, sizeof(A) / sizeof(int) - 1);      // xiao->da   
    display(A, sizeof(A)/ sizeof(int));
    
    quick_sort(A, 0, sizeof(A) / sizeof(int) - 1); // da ->xiao
    display(A, sizeof(A)/ sizeof(int));
    
    heap_sort(A, sizeof(A) / sizeof(int));
    display(A, sizeof(A) / sizeof(int));
    return 0;
}