常用排序算法代码合集（C语言，含注释）

冒泡、选择、插入、归并、快排

每个都对应一个函数，有注释，方便练习选择不同排序算法

#include <stdio.h>
void print_arr(int a[],int n);//打印数组
void guluSort(int a[],int n);//冒泡
void slctSort(int a[],int n);//选择
void insertSort(int a[],int n);//插入
void mergesort(int arr[],int left,int right,int n);//归并
void merge(int arr[],int left,int right,int n,int mid);//归并_合并数组
void quickSort(int a[],int left,int right);//快排
int devide(int a[],int left,int right);//快排_划分数组

int main(){
    int a[6]={9,8,5,2,1,1};

    /*自由选择以下排序算法*/
    //slctSort(a,6);
    //guluSort(a,6);
    //slctSort(a,6);
    //insertSort(a,6);
    //mergesort(a,0,5,6);
    quickSort(a,0,5);
    print_arr(a,6);

    return 0;
}

//打印数组元素
void print_arr(int a[],int n){
    for(int i=0;i<n;i++){
        printf("%d",a[i]);
    }
}

//冒泡泡排序
void guluSort(int a[],int n){
for(int i=0;i<n-1;i++){
        for(int j=0;j<n-1-i;j++){
            if(a[j]>a[j+1]){
                int temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
            }
        }
    }
    return;
}

//选择排序
void slctSort(int a[],int n){
 int min,x;
    for(int i=0;i<6;i++){
        min=a[i];//每次把当前第一个当作最小值
        for(int j=i+1;j<6;j++){//从下一个开始遍历，看是否有比最小值还要小的
            if(a[j]<min){
              min=a[j];x=j;
            }
        }
        if(min!=a[i]){//后面的数存在比第一个小，则交换，若不存在，不可交换
         a[x]=a[i];
         a[i]=min;
      }
    }
    return;
}

//插入排序
void insertSort(int a[],int n){
	int min,k;
    for(int i=0;i<n;i++){
        for(int j=i+1;j<n;j++){//j从i后面开始遍历
            if(a[j]<a[i]){//如果找到比待排元素首位小的，记录值和下标
                min=a[j];
                k=j;
                while(a[k-1]>min){//前面比min大的都往后移一位,最后腾出来的位置就是要插入的位置
                    a[k]=a[k-1];
                    k--;
                }
                a[k]=min;//插入数据
            }
        }
    }
    return;
}

//归并排序_合并
void merge(int arr[],int left,int right,int n,int mid){
    //定义临时数组用于合并
    int temparr[n];
    //标记左半部分起始位置
    int l=left;
    //标记左半部分起始位置
    int r=mid+1;
    //标记临数组起始位置(因为后面要写回原数组，直接用left，left会变化，会丢失起始位置)
    int temp_l=left;
    //只要两部分没比较完，就一直循环
    while(l<=mid&&r<=right){
        //左边小，左边加入数组
        if(arr[l]<=arr[r]){
            temparr[temp_l++]=arr[l++];
        }
        //右边小，右边加入数组
        else temparr[temp_l++]=arr[r++];
    }
    //左半部分有剩余，全部挂到数组后面
    while(l<=mid){
        temparr[temp_l++]=arr[l++];
    }
    //右半部分有剩余，全部挂到数组后面
    while(r<=right){
        temparr[temp_l++]=arr[r++];
    }
    //将临时数组数据写回原数组
    while(left<=right){
        arr[left]=temparr[left];
        left++;
    }
}
//归并排序
void mergesort(int arr[],int left,int right,int n){
    //只有一个元素时，直接返回
    if(left>=right) return;
    //划分为两部分
    int mid=(left+right)/2;
    //递归划分左半部分
    mergesort(arr,left,mid,n);
    //递归划分左半部分
    mergesort(arr,mid+1,right,n);
    //划分完以后，开始合并
    merge(arr,left,right,n,mid);
    return;
}

//快排一次划分
int devide(int a[],int left,int right){
    //选取划分的基准值，默认为第一个数
    int mid=a[left];
    while(left<right){
            //只要比基准值大，就左移，直到找到比基准值小的数
            //(里面while也要判断left<right的原因:
            //里面left和right会变化可能会不满足left<right)
        while(left<right&&a[right]>=mid) right--;
        a[left]=a[right];
        //只要比基准值小，就右移，直到找到比基准值小的数
        while(left<right&&a[left]<mid) left++;
        a[right]=a[left];
    }
    a[left]=mid;
    return left;;
}
//快速排序
void quickSort(int a[],int left,int right){
    if(left<right){
        int m=devide(a,left,right);//先划分一次
        quickSort(a,left,m-1);//递归左半部分
        quickSort(a,m+1,right);//递归右半部分
    }
}