各种排序算法

#include<stdio.h>

#include<stdlib.h>

#include<time.h>

#include<string.h>

#define SIZE 8

#define LEFT(x) (2*(x)+1)

#define RIGHT(x) (2*(x)+2)

 

void insert_sort(int arr[]);                                   /* 插入排序 */ 

void merge_sort(int arr[], int first, int last);        /* 归并排序 */ 

void merge(int arr[], int first, int middle, int last);

void bubble_sort(int arr[]);                                 /* 冒泡排序 */ 

void max_heapify(int arr[], int i);                     

void build_heap(int arr[]);                             

void heap_sort(int arr[]);                                     /* 堆排序 */ 

void randomQuick_sort(int arr[], int p, int r);        /* 随机快速排序 */ 

int random_partition(int arr[], int p, int r);          

void choose_sort(int arr[]);                                  /* 选择排序 */ 

void counting_sort(int a[], int b[], int k);              /* 计数排序 */ 

void print_array(int arr[]);                            

void swap(int *a, int *b);                              

 

int heap_size = SIZE;

 

int main(int argc, int** argv[])

{

    int array[SIZE] = {50, 38, 48, 97, 49, 13, 27, 65};

    insert_sort(array);

    printf("Insert sort:/n");

    print_array(array);

 

    int array2[SIZE] = {50, 38, 48, 97, 49, 13, 27, 65};

    merge_sort(array2, 0, SIZE-1);

    printf("Merge sort:/n");

    print_array(array2);

 

    int array3[SIZE] = {50, 38, 48, 97, 49, 13, 27, 65};

    printf("Bubble sort:/n");

    bubble_sort(array3);

    print_array(array3);

 

    int array4[SIZE] = {50, 38, 48, 97, 49, 13, 27, 65};

    printf("Heap sort:/n");

    heap_sort(array4);

    print_array(array4);

 

    int array5[SIZE] = {50, 38, 48, 97, 49, 13, 27, 65};

    printf("Random qucik sort:/n");

    randomQuick_sort(array5, 0, SIZE-1);

    print_array(array5);

 

    int array6[SIZE] = {50, 38, 48, 97, 49, 13, 27, 65};

    printf("Choose sort:/n");

    choose_sort(array6);

    print_array(array6);

 

    int array7[SIZE] = {2, 5, 3, 0, 2, 3, 0, 3};

    int* b = (int*)malloc((SIZE)*sizeof(int));

    memset(b, 0, SIZE*sizeof(int));

    printf("Counting sort:/n");

    counting_sort(array7, b, 5);

    print_array(b);

 

    getchar();

    return 0;

}

 

void print_array(int arr[])

{

    int i;

    for(i=0; i<SIZE; i++)

    {

        printf("%d ", arr[i]);

    }

    printf("/n");

}

 

void insert_sort(int arr[])

{

    int i, j;

    int temp;

    for(i=1; i<SIZE; i++)

    {

        temp = arr[i];

        j = i-1;

        while(j>=0 && arr[j]>temp)

        {

            arr[j+1] = arr[j];

            j--;

        }

        arr[j+1] = temp;

    }

}

 

void merge_sort(int arr[], int first, int last)

{

    int middle = 0;

    if(first<last)

    {

        middle = (first+last)/2;

        merge_sort(arr, first, middle);

        merge_sort(arr, middle+1, last);

        merge(arr, first, middle, last);

    }

}

 

void merge(int arr[], int p, int q, int r)

{

    int i, k;

    int begin1, end1, begin2, end2;

    int* temp = (int*)malloc((r-p+1)*sizeof(int));

    begin1 = p;

    end1 = q;

    begin2 = q+1;

    end2 = r;

    k = 0;

    while((begin1<=end1)&&(begin2<=end2))

    {

        if(arr[begin1]<arr[begin2])

        {

            temp[k] = arr[begin1];

            begin1++;

        }

        else

        {

            temp[k] = arr[begin2];

            begin2++;

        }

        k++;

    }

    while(begin1<=end1)    temp[k++] = arr[begin1++];

    while(begin2<=end2)    temp[k++] = arr[begin2++];

    for(i=0; i<r-p+1; i++)

    {

        arr[p+i]=temp[i];

    }

    free(temp);

     /*

    int n1, n2;

    int i, j;

    n1 = q-p+1;

    n2 = r-q;

    int* L = (int*)malloc((n1)*sizeof(int));

    int* R = (int*)malloc((n2)*sizeof(int));

    for(i=0; i<n1; i++)

    {

        L[i] = arr[p+i];

    }

    for(j=0; j<n2; j++)

    {

        R[j] = arr[q+j+1];

    }

    i=p;

    j=q+1;

 

    while((i<(q+1))&&(j<r))

    {

        if(L[i]<R[j])

        {

            arr[p] = L[i];

            i++;

        }

        else

        {

            arr[p] = R[j];

            j++;

        }

    }

    while(i<(q+1))

    {

        arr[p] = L[i];

        i++;

    }

    while(j<r)

    {

        arr[p] = R[j];

        j++;

    }

    */

}

 

void bubble_sort(int arr[])

{   

    int i,j,temp;

    bool isSwap;

    for(i=SIZE-1; i>0; i--)

    {

        isSwap = false;

        for(j=0; j<i; j++)

        {

            if(arr[j]>arr[j+1])

            {

                temp = arr[j];

                arr[j] = arr[j+1];

                arr[j+1] = temp;

                isSwap = true;

            }

        }

        if(!isSwap) break;

    }

}

 

void max_heapify(int arr[], int i)

{

    int l = LEFT(i);

    int r = RIGHT(i);

    int temp;

    int largest;

    if(l<heap_size && arr[l]>arr[i])

        largest = l;

    else

        largest = i;

    if(r<heap_size && arr[r]>arr[largest])

        largest = r;

    if(largest != i)

    {

        temp = arr[i];

        arr[i] = arr[largest];

        arr[largest] = temp;

        max_heapify(arr, largest);

    }

}

 

void build_heap(int arr[])

{

    int i;

    for(i=SIZE/2-1; i>=0; i--)

    {

        max_heapify(arr, i);

    }

}

 

void heap_sort(int arr[])

{

    int i;

    int temp;

    build_heap(arr);

    for(i = SIZE-1; i>=1; i--)

    {     

        temp = arr[0];

        arr[0] = arr[i];

        arr[i] = temp;

        heap_size -= 1;

        max_heapify(arr, 0);

    }

}

 

void randomQuick_sort(int arr[], int p, int r)

{

    int q;

    if(p<r)

    {

        q = random_partition(arr, p, r);

        randomQuick_sort(arr, p, q-1);

        randomQuick_sort(arr, q+1, r);

    }

}

 

int random_partition(int arr[], int p, int r)

{

    int ran;

    int i, j;

    srand((unsigned)time(NULL));

    ran = rand()%(r-p)+p;

    swap(&arr[ran], &arr[r]);

    i = p-1;

    for(j=p; j<r; j++)

    {

        if(arr[j]<arr[r])

        {

            i++;

            swap(&arr[i],&arr[j]);

        }

    }

    swap(&arr[i+1], &arr[r]);

    return i+1;

}

 

void choose_sort(int arr[])

{

    int i, j, min;

    for(i=0; i<SIZE-1; i++)

    {

        min = i;

        for(j=i+1; j<SIZE; j++)

        {

            if(arr[j]<arr[min])

            {

                min = j;

            }

        }

        swap(&arr[i], &arr[min]);

    }

}

 

void counting_sort(int a[], int b[], int k)

{

    int* c = (int*)malloc((k+1)*sizeof(int));

    memset(c, 0, sizeof(int)*(k+1));

    for(int i=0; i<SIZE; i++)

    {

        c[a[i]] = c[a[i]]+1;

    }

 

    for(int i=1; i<=k; i++)

    {

        c[i] = c[i] + c[i-1];

    }

    for(int i=SIZE-1; i>=0; i--)

    {

        b[c[a[i]]] = a[i];

        c[a[i]] = c[a[i]] - 1;

    }

 

}

 

void swap(int *a, int *b)

{ 

  int t=*a; *a=*b; *b=t; 

}