五种经典排序算法详解：冒泡、插入、Shell、堆排序与归并排序-CSDN博客

1.优化冒泡

#include<stdio.h>
#include<stdlib.h>
#define MAX_size 100
typedef struct{
    int a[MAX_size];
    int length;
}SqLiszt;
void
swap(SqLiszt *L,int i,int j){
    int temp = L->a[i];
    L->a[i]= L->a[j];
    L->a[j]= temp;
}
void 
Bubble_sort(SqLiszt *L){
      int i,j,flag = 1;
       for(i=1;i<L->length && flag ;i++){
           flag = 0;
             for(j=L->length-1;j>=i;j--){ //从后往前 小的在当前j  是下一轮的j+1  
                  if(L->a[j]>L->a[j+1]){
                        swap(L,j,j+1);
                        flag =1;
                  }
             }
       }

}

int main(){
     SqLiszt L;
     L.length =0; //要初始化 为 0！！！！！
     int temp;
        for(int i =1;i<=10;i++){
              scanf("%d",&temp);
              L.a[i] = temp;
              L.length ++;
        }

         Bubble_sort(&L);
        printf("排序后的结果为：\n");
             for(int i= 1; i<=L.length;i++){
                  printf("%d ",L.a[i]);
             }

    return 0;
}

2.直接插入排序

#include<stdio.h>
#include<stdio.h>
#define MAX_size 100
typedef struct{
    int a[MAX_size];
    int length;
}SqLiszt;
void
swap(SqLiszt *L,int i,int j){
    int temp = L->a[i];
    L->a[i]= L->a[j];
    L->a[j]= temp;
}
void 
Insert_sort(SqLiszt *L){
    int i ,j;
     for(i=2;i<=L->length;i++){ // [0] 做额为空间  【1】 相当于已经排好
            if( L->a[i-1]>L->a[i] ){
                  L->a[0] = L->a[i];
                   for(j=i-1; L->a[j]>L->a[0] ;j--){//如果大于插入的 向后移一位
                          L->a[j+1]=L->a[j];
                   }
                      L->a[j+1]= L->a[0];   //最后j-- 定位到比插入的值小的位置 
            }
          
     }
}
int main(){
     SqLiszt L;
     L.length =0; //要初始化 为 0！！！！！
     int temp;
        for(int i =1;i<=10;i++){
              scanf("%d",&temp);
              L.a[i] = temp;
              L.length ++;
        }

        Insert_sort(&L);
        printf("排序后的结果为：\n");
             for(int i= 1; i<=L.length;i++){
                  printf("%d ",L.a[i]);
             }

    return 0;
}

3.shell

#include<stdio.h>
#include<stdio.h>
#define MAX_size 100
typedef struct{
    int a[MAX_size];
    int length;
}SqLiszt;
void 
Shell_sort(SqLiszt *L){
    int increment = L->length;
    int j,i;
      do{
           increment /=2;//初始分为五组， 增量越小 一组内元素越多
            for( i= increment+1; i<=L->length; i++){ //排一次 基本有序 
                  if( L->a[i]<L->a[i-increment] ){ // 将 a【i】 插入到自己的增量组中
                       L->a[0]= L->a[i];
                        for(j=i-increment;j>0 &&  L->a[j] > L->a[0] ;j-=increment){
                                 L->a[j+increment]= L->a[j]; //初始 j 就是上一个位置 ，所以要加步长才是原本要插入的位置  --》 增量组整体后移
                        }
                           L->a[j+increment]= L->a[0];
                  }
            }
      } while(increment >1 ); //增量为 1 才结束 表示分为一个组
}
int main(){
     SqLiszt L;
     L.length =0; //要初始化 为 0！！！！！
     int temp;
        for(int i =1;i<=10;i++){
              scanf("%d",&temp);
              L.a[i] = temp;
              L.length ++;
        }

        Shell_sort(&L);
        printf("排序后的结果为：\n");
             for(int i= 1; i<=L.length;i++){
                  printf("%d ",L.a[i]);
             }

    return 0;
}

4.堆排序

#include<stdio.h>
#include<stdio.h>
#define MAX_size 100
typedef struct{
    int a[MAX_size];
    int length;
}SqLiszt;
void Heap_max(SqLiszt *L,int s,int max);
void
swap(SqLiszt *L,int i,int j){
    int temp = L->a[i];
    L->a[i]= L->a[j];
    L->a[j]= temp;
}
void 
Heap_sort(SqLiszt *L){
    for(int i = L->length/2;i>=1;i--){
         Heap_max(L,i,L->length);   //将每个非叶子子树排序为大顶堆 -》从下到上
    }
      for(int i = L->length ; i>1;i--){
          swap(L,1,i);   //将跟（最大的元素） 换为尾部 
          Heap_max(L,1,i-1); // 排除已挑选最大的元素 重新变长大顶堆 循环 
      }

}
void 
Heap_max(SqLiszt *L,int s,int max){   // s - max  构成大顶堆 
        L->a[0] =  L->a[s];
          int i;
          for( i = s*2;i<= max;i*=2){ //*2 为左子树 
             if( i<max &&L->a[i] < L->a[i+1])
                      i++; //定位到大的 子树（右子树  如果有
                if(L->a[0] >= L->a[i])
                      break;
                      //能执行到这 说明子元素大于跟 互换 
                  L->a[s]= L->a[i];  
                        s = i; // 往子树走 
          }
            L->a[s]= L->a[0]; // 找到自己位置 
         
}
int main(){
     SqLiszt L;
     L.length =0; //要初始化 为 0！！！！！
     int temp;
        for(int i =1;i<=10;i++){
              scanf("%d",&temp);
              L.a[i] = temp;
              L.length ++;
        }

       Heap_sort(&L);
        printf("排序后的结果为：\n");
             for(int i= 1; i<=L.length;i++){
                  printf("%d ",L.a[i]);
             }

    return 0;
}

5.归并排序（递归版

#include<stdio.h>
#include<stdlib.h>
#define MAX_size 100
typedef struct{
    int a[MAX_size];
    int length;
}SqLiszt;
void Merge(int *sr,int *tr,int i,int m,int n){  //m为中间数  归并到tr  sr  1-m
          int p1 =i,p2=m+1,temp = i;
            while(p1<=m&& p2<=n){
                  if(sr[p1]<sr[p2])
                      tr[temp++]= sr[p1++];
                        else 
                          tr[temp++]= sr[p2++];

            }
              while(p1<=m){
                     tr[temp++]= sr[p1++];
              }
              
              while(p2<=n){
                    tr[temp++]= sr[p2++];

              }
             
}
void M_Sort(int *sr, int *tr1,int s,int t){ //s 为第一个 ，t 为最后一个 
         int mid;
          int tr2[MAX_size]; 
           if(s==t){
                tr1[s]= sr[s];
           }
               else{
                    mid = (s+t)/2;
                       M_Sort(sr,tr2,s,mid);  
                       M_Sort(sr,tr2,mid+1,t);
                       Merge(tr2,tr1,s,mid,t);
                }
                 
}
void 
Merge_sort(SqLiszt *L){
        M_Sort(L->a,L->a,1,L->length);
}
int main(){
     SqLiszt L;
     L.length =0;
     int temp;
        for(int i =1;i<=10;i++){
              temp = 10-i;
              L.a[i] = temp;
              L.length ++;
        }

       Merge_sort(&L);
        printf("排序后的结果为：\n");
             for(int i= 1; i<=L.length;i++){
                  printf("%d ",L.a[i]);
             }

    return 0;
}

#include<stdio.h>
#define MAX_size 100
typedef struct{
    int a[MAX_size];
    int length;
}SqLiszt;
void
swap(SqLiszt *L,int i,int j){
    int temp = L->a[i];
    L->a[i]= L->a[j];
    L->a[j]= temp;
}
int 
Partition(SqLiszt *L,int low,int high){
     //改进1 三值取中间 
    int mid = (low+high)/2;
    if(L->a[low]>L->a[high])
       swap(L,low,high);
    if(L->a[mid]>L->a[high])
       swap(L,mid,high);
    if(L->a[low]> L->a[mid])
       swap(L,low,mid);
//---------
   int pivot = L->a[low];
   L->a[0]=pivot; //改进2 不用交换，存储 替代 
   while(low<high){
      while(low<high&& pivot <= L->a[high]){  // 找到一个小于初始值的换到左边
                      high--;
      }
            L->a[low]= L->a[high];
      
      while(low<high && pivot >= L->a[low]){
            low++;             //找到一个大于初始值的换到右边
      }
           L->a[high]= L->a[low];
   }
   L->a[low] = L->a[0]; //储存的值填入
   return low;

     
}   

void 
Qsort(SqLiszt *L,int low ,int high){
    int pivot;
      while(low<high){ //改进3  尾部递归可以换成迭代！
           pivot = Partition(L,low,high); 
             Qsort(L,low,pivot-1);
             low = pivot +1;  //再进while循环 pivot 相当于 Qsort  
      }
}
void 
Quick_sort(SqLiszt *L){
   Qsort(L,1,L->length);
}
int main(){
     SqLiszt L;
     L.length =0;
     int temp;
        for(int i =1;i<=10;i++){
              scanf("%d",&temp);
              L.a[i] = temp;
              L.length ++;
        }

       Quick_sort(&L);
        printf("排序后的结果为：\n");
             for(int i= 1; i<=L.length;i++){
                  printf("%d ",L.a[i]);
             }

    return 0;
}