排序

 

/*****************************************************
 *author：chen xin
 *email：cx2pirate@gmail.com
 *date：2014.09.08
 * **************************************************/


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

#define _TEST_SIZE 512
#define MAX_DATA 10000

void gen_rand_data(int *arr,size_t size);
void swap(int *a,int *b);
void bubble_sort(int *arr,size_t size);
void print_array(int *arr,size_t size);
void select_sort(int *arr,size_t size);
void insert_sort(int *arr,size_t size);
void shell_sort(int *arr,size_t size);

void merge_sort(int *arr,size_t size);
void _merge_sort(int *arr,int low,int high);
void _merge(int *arr,int low,int mid,int high);

void quick_sort(int *arr,size_t size);
void _quick_sort(int *arr,int low,int high);

void heap_sort(int *arr,size_t size);
void _make_heap(int *arr,int low,int high);
void _adjust_heap(int *arr,int low,int high,int par);

int main(void)
{
    int arr[_TEST_SIZE];

    gen_rand_data(arr,_TEST_SIZE);
    //bubble_sort(arr,_TEST_SIZE);
    //select_sort(arr,_TEST_SIZE);
    //insert_sort(arr,_TEST_SIZE);
    //shell_sort(arr,_TEST_SIZE);
    //merge_sort(arr,_TEST_SIZE);
    //quick_sort(arr,_TEST_SIZE);
    heap_sort(arr,_TEST_SIZE);
    print_array(arr,_TEST_SIZE);
}

void gen_rand_data(int *arr,size_t size)
{
    srand(time(NULL));
    for(int i = 0;i < size;i++){
        arr[i] = rand() % MAX_DATA;
    }
}

void print_array(int *arr,size_t size)
{
    for(int i = 1;i <= size;i++){
        printf("%8d",arr[i]);
        if(i % 5 == 0) printf("\n");
    }
}

void swap(int *a,int *b)
{
    int t = *a;
    *a = *b;
    *b = t;
}


//o(n^2)
void bubble_sort(int *arr,size_t size)
{
    for(int i = 0;i < size - 1;i++){
        for(int j = 0;j < size - i - 1;j++){
            if(arr[j] > arr[j + 1]){
                swap(&arr[j],&arr[j + 1]);
            }            
        }
    }
}

//o(n^2)
void select_sort(int *arr,size_t size)
{
    for(int i = 0;i < size - 1;i++){
        int mini = i;
        for(int j = i + 1;j < size - 1;j++){
            mini = arr[mini] < arr[j] ? mini : j;
        }
        if(mini != i)
            swap(&arr[mini],&arr[i]);
    }
}

//o(n^2)
void insert_sort(int *arr,size_t size)
{
    //循环不变式arr[i]之前已排序
    for(int i = 1;i < size;i++){
        int temp = arr[i];
        int j;

        for(j = i;j > 0 && temp < arr[j - 1];j--){
            arr[j] = arr[j - 1];
        }

        arr[j] = temp;
    }
}

//分段插入排序，step=1即为插入排序
void shell_sort(int *arr,size_t size)
{
    for(int step = size / 2;step > 0;step /= 2){
        for(int i = step;i < size;++i){
            int temp = arr[i];
            int j;
            for(j = i - step;j >= 0 && temp < arr[j];j -= step){
                arr[j + step] = arr[j];
            }
            arr[j + step] = temp;
        }
    }
}

//nlg(n)
void merge_sort(int *arr,size_t size)
{
    _merge_sort(arr,0,size - 1);
}

// nlg(n)
void _merge_sort(int *arr,int low,int high)
{
    if(low >= high){
        return; 
    }

    int mid = (low + high) / 2;
    _merge_sort(arr,low,mid);
    _merge_sort(arr,mid + 1,high);
    _merge(arr,low,mid,high);
}

void _merge(int *arr,int low,int mid,int high)
{
    int *tmp_arr = (int *)malloc((high - low + 1) * sizeof(int));
    if(tmp_arr == NULL){
        return;
    }

    int i = low;
    int j = mid + 1;
    int cnt = 0;

    while(i <= mid && j <= high){
        tmp_arr[cnt++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];
    }
    while(i <= mid){
        tmp_arr[cnt++] = arr[i++];
    }
    while(j <= high){
        tmp_arr[cnt++] = arr[j++];
    }
    memcpy(arr + low,tmp_arr,(high - low + 1) *sizeof(int));
    
    free(tmp_arr);
}

// o(n^2) 
void quick_sort(int *arr,size_t size)
{
    _quick_sort(arr,0,size - 1);
}

void _quick_sort(int *arr,int low,int high)
{
    if(low >= high)
        return;

    int mid_val = arr[high];            //参考值

    int i = low - 1;
    for(int j = low;j <= high;j++){
        if(arr[j] <= mid_val){
            swap(&arr[j],&arr[++i]);    
        }
    }

    _quick_sort(arr,low,i - 1);
    _quick_sort(arr,i + 1,high);
}

// nlgn
void heap_sort(int *arr,size_t size)
{
    _make_heap(arr,0,size - 1);
    for(int high = size - 1;high > 0;high--){
        _adjust_heap(arr,0,high,0);
        swap(&arr[0],&arr[high]);
    }
}

void _make_heap(int *arr,int low,int high)
{
    if(low >= high)
        return;
    
    int par = (high - low) / 2 - 1;                    //第一个待调整节点
    for(;par >= 0;par--){
        _adjust_heap(arr,low,high,par);
    }
}

void _adjust_heap(int *arr,int low,int high,int par)
{
    int t = arr[par];

    for(int i = 2 * par + 1;i <= high;i++){
        if(i < high && arr[i + 1] > arr[i]){
            ++i;
        }

        if(t >= arr[i]){
            break;
        }
        arr[par] = arr[i];
        par = i;                            //向下移
    }

    arr[par] = t;
}