排序汇总

1.

[code]//排序汇总 
#include<stdio.h>
#include <time.h>

#define arr_len(array) (sizeof(array) / sizeof(array[0]))
clock_t start_time, end_time;

void swap(int *arr, int i, int j){
    int temp = arr[i];
    arr[i]  = arr[j];
    arr[j] = temp;
}
//1. 输出源数据
void print_arr(int *arr, int n){
    int len = n;
    int i = 0;
    for(i; i < len; i++){
        printf("%d ", arr[i]);
    } 
    printf("\n");
} 

//2. 冒泡排序
void bubble_sort(int *arr, int n){
    start_time = clock(); 
    int i = 0, j = 0;
    int len = n;
    for(i; i < len; i++){
        for(j = len - 1; j > 0; j--){
            if(arr[j] < arr[j - 1]){
                swap(arr, j, j - 1);
            }
        }
    }
    end_time = clock(); 
    printf("用时: %d ms\n", end_time - start_time);
} 
//3. 选择排序
void select_sort(int *arr, int n){
    start_time = clock(); 
    int i = 0, j = 0;
    int min = 0;
    for(i; i < n; i ++){
        min = i;
        for(j = i + 1; j < n; j++){
            if(arr[min] > arr[j]){
                min = j;        //存放最小值的下标 
            }
        }
        if(i != min){
            swap(arr, i, min);
        } 
    }
    end_time = clock(); 
    printf("用时: %d ms\n", end_time - start_time);
} 
//4.插入排序
void insert_sort(int *arr, int len){  
    start_time = clock(); 
    int i = 1, j = 0, index = 0, temp = 0;
    for(i; i < len; i++){
        temp = arr[i];
        index = i;
        for(j = i - 1; j >= 0; j--){
            if(arr[j] > temp){
                arr[j + 1] = arr[j];
                index = j;
            }
        }
        arr[index] = temp;
    }
    end_time = clock(); 
    printf("用时: %d ms\n", end_time - start_time);
} 
//5. 希尔排序 -- 基于插入排序实现 
void shell_sort(int *arr, int len){
    start_time = clock(); 
    int i = 1, j = 0, index = 0, temp = 0;
    int k = len / 2;
    while(k){
        for(i = k; i < len; i++){           
            temp = arr[i];
            index = i;
            for(j = i - k; j >= 0; j -= k){
                if(arr[j] > temp){
                    arr[j + k] = arr[j];
                    index = j;
                }
            }
            arr[index] = temp;
        }
        k /= 2;
    }
    end_time = clock(); 
    printf("用时: %d ms\n", end_time - start_time);
} 
//6. 快排序 -- 基于冒泡排序
void quick_sort(int *arr, int low, int high){
    start_time = clock(); 
    if(low >= high){
        return;
    }
    int start = low;
    int end = high;
    int key = arr[start];
    while(end > start){
        //找右半部分小于key的值
        while(start < end && arr[end] >= key) {
            --end;
        }
        arr[start] = arr[end];

        //找做半部分大于key的值
        while(start < end && arr[start] <= key) {
            ++start;
        }
        arr[end] = arr[start];
    }
    arr[start] = key;   //起始位置保留: 起始位置是while循环中的位置 
    quick_sort(arr, low, start - 1);
    quick_sort(arr, start + 1, high) ;
    end_time = clock(); 
    printf("用时: %d ms\n", end_time - start_time);
} 
//7. 堆排序 -- 基于选择排序
/*
    1. 初始化大顶堆
    2. 大顶堆和最后一个数据交换后, 在构建 大顶堆 
    注: 数组的坐标是从0开始的 
*/
//大顶堆
void heap_adjust(int arr[], int n, int len) {
    int max;    //记录结点的最大值 下标 
    while(2 * n + 1 < len){ //是否有左结点 
        max = 2 * n + 1;
        if(2 * n + 2 < len) {   //有右结点
            if(arr[2 * n + 2] > arr[max]){  //右结点是否大于左结点 
                 max += 1;
            } 
        }
        if(arr
 > arr[max]) { //根结点和子树比较 
            break;
        }
        swap(arr, n, max);
        n = max;            //根结点为最大子树 
    }
}
//堆排序
void heap_sort(int arr[], int len) {
    //构建一个大顶堆,,从最后一个叶子结点开始 
    start_time = clock(); 
    int i, j;
    for(i = len / 2 - 1; i >= 0; i--) { //i = 0; 表示是根结点 
        heap_adjust(arr, i, len);
    }
    for(j = len - 1; j > 0; j--){   //交换的次数,  
        swap(arr, j, 0);            //第一结点是最大值, 和最后一个结点交换 
        heap_adjust(arr, 0, j);         //根结点从0开始, 从新构造 
    }
    end_time = clock(); 
    printf("用时: %d ms\n", end_time - start_time);
}
int main(void){
    int nums[] = {10,100,1000,10000,30000,50000}; 
    int size = nums[0]; //默认是 10个数据 
    int m = 0, i = 0, num_len;
    int arr1[size],arr2[size],arr3[size],arr4[size],arr5[size],arr6[size],arr7[size];
    for(m = 0; m < size; m++){
            int tmpNum = size - m;
            arr1[m] = tmpNum;
            arr2[m] = tmpNum;
            arr3[m] = tmpNum;
            arr4[m] = tmpNum;
            arr5[m] = tmpNum;
            arr6[m] = tmpNum;
    }
    int len = arr_len(arr1);
    int option = 1;
    printf(" 1. 输出源数据\n 2. 冒泡排序\n 3. 选择排序\n 4. 插入排序\n 5. 希尔排序\n 6. 快速排序\n 7. 堆排序\n 0. 退出\n");
    while(option){
        scanf("%d", &option);
        switch(option){
            case 1:
                print_arr(arr1, len);
                break;
            case 2:
                bubble_sort(arr1, len);
                print_arr(arr1, len);
                break;
            case 3:
                select_sort(arr2, len);
                print_arr(arr2, len);
                break;
            case 4:
                insert_sort(arr3, len);
                print_arr(arr3, len);
                break;
            case 5:
                shell_sort(arr4, len);
                print_arr(arr4, len);
                break;
            case 6:
                quick_sort(arr5, 0, len - 1);
                print_arr(arr5, len);
                break;
            case 7:
                heap_sort(arr6, len);
                print_arr(arr6, len);
                break;          
            case 0:
                return 0;
                break;
            default:
                printf(" 1. 输出源数据\n 2. 冒泡排序\n 3. 选择排序\n 4. 插入排序\n 5. 希尔排序\n 6. 快速排序\n 7. 堆排序\n 0. 退出\n");
                break; 
        }
    }
    return 0;
}