六大基础排序（冒泡，插入，选择，希尔，快速，归并）——C语言版

#include "stdio.h"

int i,j,k,l,temp;

void Menu();
void bubble_sort(int array[] , int n);
void selective_sort(int array[] , int n);
void insertion_sort(int array[] , int n);
void quick_sort(int array[] , int low , int high , int n);
int partition(int array[] , int low , int high , int n);
void hill_sort(int array[] , int n);
void sort_array(int array[] , int n);
void merge_sort(int array[]  ,int num[] , int left , int right , int n);

int main() {
    int n,option;
    while(1){
        printf("请输入数组个数：");
        scanf("%d",&n);
        int array[n];
        printf("请输入数组数据：");
        for(i = 0 ; i < n ; i++)  scanf("%d",&array[i]);
        Menu();
        printf("请输入排序选项：");
        scanf("%d",&option);
        switch(option){
            case 1 :
                bubble_sort(array , n);
                break;
            case 2 :
                selective_sort(array , n);
                break;
            case 3 :
                insertion_sort(array , n);
                break;
            case 4 :
                quick_sort(array , 0 , n-1 , n);
                printf("思路：找到基准点，比基准点小的数据放到基准点左边，比基准点大的放到基准点的右边，再分别对基准点左边和右边的数据进行内部排序，快速排序速度比较快，所以多出了许多无效数据（适合数据量大且乱序）\n\n");
                break;
            case 5 :
                hill_sort(array , n);
                break;
            case 6 :
                sort_array(array , n);
                printf("思路：分而治之，把数组依次分组，然后组内排序\n\n");
                break;
            case 7 :
                printf("退出成功！");
                return 0;
            default :
                printf("请输入正确的选项！");
                break;
        }
    }
}

void Menu(){
    printf("------------------------递增排序----------------------------------\n");
    printf("                      ①冒泡排序（时间复杂度：O（n2）\n");
    printf("                      ②选择排序（时间复杂度：O（n2）\n");
    printf("                      ③插入排序（时间复杂度：O（n2）\n");
    printf("                      ④快速排序时间复杂度：O（n2）或O(N * logN)\n");
    printf("                      ⑤希尔排序（时间复杂度：O（n2）\n");
    printf("                      ⑥归并排序（时间复杂度：O(N * logN)）\n");
    printf("                      ⑦退出\n");
    printf("--------------------------------------------------------------\n");
}

void bubble_sort(int array[] , int n){
    printf("排序过程：\n");
    for(i = n - 1 ; i >= 0 ; i--){
        for(j = 0 ; j < i ; j++){
            if(array[j] > array[j+1]){
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
        for(k = 0 ; k < n ; k++)  printf("%d ",array[k]);
        printf("\n");
    }
    printf("思路：依次将最大的数据放到数组末尾，然后不管它，再接着把未处理数据中的最大数字放到数组后端，以此类推\n\n\n");
}

void selective_sort(int array[] , int n){
    printf("排序过程：\n");
    int min_index;
    for(i = 0 ; i < n - 1 ; i++){
        min_index = i;
        for(j =  i + 1 ; j < n ; j++){
            if(array[j] < array[min_index])  min_index = j;
        }
        if(i != min_index){
            temp = array[i];
            array[i] = array[min_index];
            array[min_index] = temp;
        }
        for(k = 0 ; k < n ; k++)  printf("%d ",array[k]);
        printf("\n");
    }
    printf("思路：找打最小数与索引调换位置，将合适的数放到合适的位置\n\n");
}

void insertion_sort(int array[] , int n){
    printf("排序过程：\n");
    for(i = 1 ; i < n ; i++){
        for(j = i ; j > 0 ; j--){
            if(array[j-1] > array[j]){
                temp = array[j-1];
                array[j-1] = array[j];
                array[j] = temp;
            }
        }
        for(k = 0 ; k < n ; k++)  printf("%d ",array[k]);
        printf("\n");
    }
    printf("思路：将未排序的数字与已排序的数字进行倒序比较，若小于已排序的数字则调换位置\n\n");
}

void quick_sort(int array[] , int low , int high , int n){
    if(low < high){
        int point = partition(array , low , high , n);    //寻找基准点
        quick_sort(array , 0 , point-1 , n);    //对基准点左边进行排序
        quick_sort(array , point+1 , high , n);    //对基准点的右边进行排序
    }
}
int partition(int array[] , int low , int high , int n){
    int point = array[low];    //确认基准点
    while(low < high){
        while(low < high && array[high] >= point)  high--;    //比基准点大的数据放到基准点的右边
        array[low] = array[high];
        while(low < high && array[low] <= point)  low++;    //比基准点小的数据放到基准点的右边
        array[high] = array[low];
    }
    array[low] = point;    //和基准点的主句进行交换
    for(i = 0 ; i < n ; i++)  printf("%d ",array[i]);    //打印交换过程
    printf("\n");
    return low;    //返回目前基准点所在的位置
}

void hill_sort(int array[] , int n){
    int length,h;
    length = n;  h = 1;
    while(h < length/2)  h = h * 2 + 1;    //确认增量值
    while(h >= 1){
        for(i = h ; i < n ; i++){
            for(j = i ; j >= h ; j-= h){
                if(array[j-h] > array[j]){    //交换与增量值所对应的数据
                    temp = array[j-h];
                    array[j-h] = array[j];
                    array[j] = temp;
                }
            }
        }
        h /= 2;
        for(k = 0 ; k < n ; k++)  printf("%d ",array[k]);    //打印交换过程的数据
        printf("\n");
    }
    printf("思路：先确定一个增量值（比如3），然后从头开始与增量值所在的位置的数据进行对比交换数据（如0索引的增量位为4索引）\n\n");
}

void sort_array(int array[] , int n){
    int length,num[n];
    length = n;
    merge_sort(array , num , 0 , length-1 , n);
}
void merge_sort(int array[]  ,int num[] , int left , int right , int n){
    if(left == right)  return;    //直接结束
    int middle = left + (right - left) / 2;    //防止数据越界
    merge_sort(array , num , left , middle , n);    //树的左边
    merge_sort(array , num , middle+1 , right , n);    //树的右边

    //合并区间
    for(i = left ; i <= right ; i++)  num[i] = array[i];
    i = left;  j = middle + 1;
    for(k = left ; k <= right ; k++){    //k为插入的位置
        if(i == middle + 1){
            array[k] = num[j];
            j++;
        }
        else if(j == right + 1){
            array[k] = num[i];
            i++;
        }
        else if(num[i] < num[j]){
            array[k] = num[i];
            i++;
        }
        else{
            array[k] = num[j];
            j++;
        }
        for(l = 0 ; l < n ; l++)  printf("%d ",array[l]);    //打印交换过程的数据
        printf("\n");
    }
}