排序算法之我观 - 码农教程

笔者今年是xmu大一新生 9月初学编程学到泡排的时候就对排序这一块深入了解 (也只是很粗浅地学习了一下) 写这篇文章的初衷就是复习一下之前所学，有不足之处请不吝赐教所谓排序就是将杂乱无章的数据变得有规律这其中有五花八门的算法，时间复杂度相同的算法不一而足目前笔者只给读者展示几种基础算法 (冒泡排序，选择排序，插入排序，快速排序，基数排序，希尔排序，归并排序） (之所以没有介绍堆排序的原因是笔者也不是很懂这方面，大一上还没学数据结构） 有低效但好用，高效但不好写之类的 1.冒泡排序(Bubble Sort) 相信大家对这个应该也不陌生吧应该要熟到半分钟就能把模板打出来具体运作过程如下：比较相邻的元素，如果前一个比后一个大，就把它们两个调换位置。对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。针对所有的元素重复以上的步骤，除了最后一个。持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。分析：平均时间复杂度：两重循环：o(n^2) 稳定的算法上代码(笔者目前只学一门c，IDE是cb）图源：https://blog.csdn.net/qq_39741605/article/details/80821595

#include <stdio.h>
void swap(int *a, int *b); //交换两个数
int main()
{
    int n;
    printf("请输入要排序的数个数：");
    scanf("%d",&n);
 int   num[100000];
 int     i, j;
for(i=0;i<n;i++)
{
    scanf("%d",&num[i]);
}
for(i=0;i<n-1;i++)
{
    for(j=0;j<n-i-1;j++)        //i<n-1与j<n-i-1的由来可以由上图得到，这里不再叙述
    {
        if(num[j]>num[j+1])
        {
           swap(&num[j],&num[j+1]);
        }
    }
}
for(i=0;i<n;i++)
{
    printf("%d ",num[i]);
}
 return  0;
}
void swap(int *a, int *b)
{
 int    c;
  c = *a;
 *a = *b;
 *b =  c;
}

码风丑陋勿怪泡排其实和选择排序有点像都是在一轮排序后将最大或最小的元素“沉”到尾部或前排 //笔者注：若下标为1开头，怎么修改？其实也简单：改为：

for(i=1;i<n;i++)
{
    for(j=1;j<=n-i;j++)
    {
        if(num[j]>num[j+1])
        {
           swap(&num[j],&num[j+1]);
        }
    }
}

2.桶排序(Bucket sort) 说起来，这种排序方法时间复杂度不高(很低o(n)左右） ~~快到上天~~ 一个桶代表一个数字，数组内数字应分配到与桶编码相等的桶中去。如果一个数组中最大数不是很大的话，可以直接取数据范围的最大值如果不是的话 (要先求出数组的最大值，因为数组的最大值是决定桶数量的重要依据)。每个桶都有一个编号，编号从0开始。然后每个桶内装的是数组内等于该编号的元素的个数，初始值为0。接下来对数组内的数字进行检测，检测到该数字，对应编码的桶就＋1。当检测完毕时，各个桶就完成了对数组内数字的统计。接下来，我们可以按照桶的编号从0开始一次输出桶的编号，根据桶内数字决定这个桶输出编号的次数。如此，输出的数据必是从小到大。废话不说，上代码(我给的桶排不是空间复杂度优化过的）

#include <stdio.h>
#include <stdlib.h>
#include<memory.h>
int a[100];
int main()
{
    memset(a,0,sizeof(a));
    int n;
    printf("请输入要排序的数个数：");
    scanf("%d",&n);
    int i,b,j;
    for(i=1;i<=n;i++)
    {
        scanf("%d",&b);
        a[b]++;
    }
    for(i=1;i<=100;i++)
    {
        for(j=0;j<a[i];j++)
        {
            printf("%d ",i);
        }
    }
    return 0;
}

代码很短，但是占用内存其实不小适用范围很窄，但是在特定问题上可以把时间复杂度做到O(n)。 3.选择排序(Selection sort) 是一种简单直观的排序算法。初始时在序列中找到最小（大）元素，放到序列的起始位置作为已排序序列；然后，再从剩余未排序元素中继续寻找最小（大）元素，放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

#include <stdio.h>
#include <stdlib.h>
int n,a[100]={0};
void selective_sort(int a[],int n)
{
    int i,j,k;
    for(i=1;i<n;i++)
    {
        k=i;
        for(j=i+1;j<=n;j++)
        {
            if(a[j]<a[k])
            {
                k=j;
            }
            if(k!=i)
            {
                int temp;
                temp=a[i];
                a[i]=a[j];
                a[j]=temp;
            }
        }
    }
    for(i=1;i<=n;i++)
{
   printf("%d ",a[i]);
}
}
int main()
{
    printf("请输入要排序的数个数：");
scanf("%d",&n);
int i;
for(i=1;i<=n;i++)
{
    scanf("%d",&a[i]);
}
selective_sort(a,n);
    return 0;
}

分析：时间复杂度：o(n^2);空间复杂度：o(1); 不稳定算法 4.希尔排序(Shell Sort) 是一种对插入排序的优化平均时间复杂度：o(n^1.3);空间复杂度：o(1); 不稳定主要思想：有点类似分治将序列分割成许多元素个数相同的子序列，进行插入排序最后对整个序列进行插入排序由于在进行最后的排序之前，子序列已然保持很高的有序性，所以效率通常会比泡排，选择排序快上一些。下面以十个元素为例：初始步长一般选择为数组长度一半，10/2=5 第一趟分为5组将每一组中的元素按非递减次序排列第二趟分为5/2=2组，依次执行最后一趟整个数组进行插排

具体代码：

#include <stdio.h>
#include <stdlib.h>
int a[100];
void shell_sort(int array[], int length)
{
 int i,j,temp,gap; //gap是分组的步长
 for(gap=length/2; gap>=1; gap=gap/2)
        {
  for(i=gap+1;i<=length;i++)
  {       temp=array[i];
    for(j=i-gap;j>=1&&array[j]>temp;j-=gap)
            {array[j+gap]=array[j];}
           array[j+gap]=temp;
           int k;
                     for(k=1;k<=length;k++)
   {
      printf("%d ",array[k]);
   }
   printf("n");
        }
           for(i=1;i<=length;i++)
   {
      printf("%d ",array[i]);
   }
   printf("n");
        }
}
int main()
{
   int n;
   printf("请输入要排序的数个数：");
   scanf("%d",&n);
   int  i;
   for(i=1;i<=n;i++)
   {
       scanf("%d",&a[i]);
   }
   shell_sort(a,n);
    return 0;
}

5.插入排序(Insert Sort) 时间空间复杂度平均为o(n^2) 稳定直接插入排序即是在要排序的数组中，假设前n-1（n>=2）个数已经是排好序的，现在要把第n个数插入到前n个已经排好序的数组中，使得这n个数也变成有序的，如此反复循环，使得要排序的数组中的最后一个元素也排好序，我们可以先假设第一个数是排好序的，然后第二个数和第一个数进行比较，如果第二个数比第一个数大，那么说明前两个数排好序，无需做调整，如果第二个数比第一个数小，那么就把第一个数向后移，将第二个数放在第一个数的位置上，抽象出来就是用a[i]和a[i-1]进行比较，如果a[i]>a[i-1]，那么就说明前i个数是已经排好序的， 如果a[i]<a[i-1]，就让j=i-1,temp=a[i],然后一边将数据a[j]向后移动，一边向前搜索，直到找到a[j]<a[i]时停止，并将temp放到a[j+1]处即可。

void InsertSort(int arr[], int left, int right)
{
    int i, v;
    for (i = left; i <= right; i++) {
        v = arr[i];
        int l = left, r = i;
        int j;
        while (l < r) 
        {//在l与r之间插入排序，可以理解为解决子问题1→2→...→n
            int mid = (l + r) / 2;
            if (arr[mid] <= v)
                l = mid + 1;
            else
                r = mid;
        }
        for (j = i - 1; l <= j; j--)
            arr[j + 1] = arr[j];
        arr[l] = v;
    }
}
int main()
{  int n,i; 
 printf("请输入要排序的数个数：");  
 scanf("%d",&n);  
 for(i=1;i<=n;i++) 
  {      
  scanf("%d",&a[i]);
  } 
     InsertSort(a,1,n);  
     for(i=1;i<=n;i++)  
     {    
       printf("%d ",a[i]); 
     }   
         return 0;
  }
```

6.归并排序(Merge Sort) 用一张图来阐述原理图源：https://blog.csdn.net/yushiyi6453/article/details/76407640

归并排序是分治思想的一个很好应用将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为归并。

#include <stdio.h>
#include <stdlib.h>
int n,a[10000];
void merge(int a[],int left,int mid,int right)
{
    int i=left,j=mid+1,k=0,c[10000]={0};    
    while(i<=mid&&j<=right) 
    {     
       if(a[i]<=a[j])     
      c[k++]=a[i++];      
      else    
        c[k++]=a[j++]; 
    }    
    while(i<=mid) 
       {     
           c[k++]=a[i++];
      }
          while(j<=right)  
       {    
              c[k++]=a[j++];   
        } 
                  int f=left; 
              for(i=0;i<k;i++)
          {        
                  a[f+i]=c[i]; 
           } 
           }
       void MergeSort(int arr[], int left, int right)
       {
       if(left<right)
       {   
        int mid=(left+right)/2; 
           MergeSort(arr,left,mid);  
             MergeSort(arr,mid+1,right);    
             merge(arr,left,mid,right);
             }
             else
              return ;
       }

            int main()
            {
            printf("请输入要排序的数个数:");
            scanf("%d",&n);
            int i;for(i=1;i<=n;i++)
            {    scanf("%d",&a[i]);
            }
            MergeSort(a,1,n);
            for(i=1;i<=n;i++)
            {    
            printf("%d ",a[i]);
            }    
            return 0;
            }

7.快速排序(Quick Sort)(二十世纪十大算法、与傅里叶变换齐名) 这是笔者讲述的重点 此法由Tony Hoare在1959年发明(1961年公布),类似于归并，也有分治的一种思想，即找到一个基准数，将比它大的放在它的右边，比它小的放在它的左边. 问题来了 基准数要怎么取？ 不清楚的话先选开头的数之后有优化先上传统快排

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

void quickSort(int a[], int left, int right)
{
    if (left >= right)
        return;
    int i = left, j = right;
    while (i < j)
    {
        while (j > i && a[j] >= a[left])
            j--;
        while (i < j && a[i] <= a[left])
            i++;
        swap(a[i], (i == j) ? a[left] : a[j]);  //i和j相遇则与pivot(基准元素)交换，否则a[i]与a[j]交换
    }
    quickSort(a, left, i-1);
    quickSort(a, j+1, right);
}

但是我们会发现这样的快速排序遇到某些情况序列原本就有序、有大量重复元素等等）会进行很多完全不必要的操作，耗费大量时间。 例如，处理一个本来按非递增次序排列的数组，排序效率就退化为与冒泡排序一样o(n^2)

这样的循环要进行N轮 优化可以从这几方面入手： 1.分割地愈细，快排的优势显现越不明显，可用插排替代之。多少开始变换排序方式呢？取10个元素为基准 2.遇到连续有序数字怎么处理？ 随机化 pivot取rand()%(right-left+1)+left 可以在一定程度上防止最坏情况的出现做到以上两点快排基本达到极致但还有一种情况 3.如果所有元素都是相同的呢？ 笔者有幸拜读了某洛谷dalao写的一篇有关快排的题解，大家可以去品味一下 https://www.luogu.org/problemnew/solution/P1177?page=7 笔者不才只学习了一个可以解决以上问题，较为简短的代码

#include <stdio.h>
#include <stdlib.h>
int n,a[1000000]={0};
void swap(int *a,int *b)
{
    int temp;
    temp=*a;
    *a=*b;
    *b=temp;
}
void quicksort(int left,int right)
{
    int mid=a[(left+right)/2];
    int i=left,j=right;
    do
    {
      while(a[i]<mid)   //在左端找比基准数大的数
      {
          i++;
      }
     while(a[j]>mid)      //在右端找比基准数小的数
     {
         j--;
     }
     if(i<=j)       //找到了即为不满足要求，交换之
     {
         swap(&a[i],&a[j]);
         i++;
         j--;
    }
    }while(i<=j);
    if(left<j)quicksort(left,j);
    if(i<right)quicksort(i,right);
}
int main()
{
    printf("请输入要排序的数个数：");
scanf("%d",&n);
int i;
for(i=1;i<=n;i++)
{
    scanf("%d",&a[i]);
}
quicksort(1,n);
for(i=1;i<=n;i++)
{
    printf("%d ",a[i]);
}
    return 0;
}

以上就是七种排序方法，有不足之处请指正，笔者不胜感激。