排序算法（Gif动图演示）

冒牌排序（BubbleSort）

冒泡排序是一种比较简单的排序算法，它循环走过需要排序的元素，依次比较相邻的两个元素，如果顺序错误就交换，直至没有元素交换，完成排序。

若对n个人进行排序，我们需要n-1次比较，所以第k次比较需要进行n-k次比较。排序算法通过以数据对象的两两比较作为关键，所以可以得出，冒泡排序需要进行的

比较次数为：(n-1) + (n-2) + ... + 1 = n*(n-1) / 2，因此冒泡排序的时间复杂度为O(n^2)。

算法简介:

       1.比较相邻的元素，前一个比后一个大（或者前一个比后一个小）调换位置

       2.每一对相邻的元素进行重复的工作，从开始对一直到结尾对，这步完成后，结尾为做大或最小的数.

       3.针对除了最后一个元素重复进行上面的步骤。

       4.重复1-3步骤直到完成排序

动画演示：

 

 代码如下

#include<stdio.h>
void BuddleSort(int a[],int n){
     
    for(int i=0;i<n-1;i++){
        for( int j=0;j<n-i-1;j++){
            if(a[j]>a[j+1]){
                int swap=a[j];
                a[j]=a[j+1];
                a[j+1]=swap;
            }
        }
    }
} 
int main(){
    int a[]={6, 9，8，4，5，2，1，3，7};
    int n=sizeof(a)/sizeof(int);
    BuddleSort(a,n);
    printf("冒泡排序结果：");
    
    for (int i = 0; i < n; i++)
    {
        printf("%d ", a[i]);
    }
    return 0;
}

冒牌排序改进版：鸡尾酒排序

鸡尾酒排序：又名为定向冒泡排序，相比较于传统的冒泡排序改进方法就是加入一个标志性变量exchange，用于标志某次排序过程中

是否由数据交换，若某一次排序没有进行数据交换，则说明数据已经排列好，可以立刻结束排序，避免不必要的后续比较过程，从而提高性能。

算法描述：每次排序进行正向和反向冒泡一次得到两个终值(最大值和最小值)。

代码如下

#include<stdio.h>
void BuddleSort(int a[],int n)
{
    int left=0;   //设置变量初始值 
    int right=n-1;
    int swap,j;
    while(left<right){
        for(j=left;j<right;j++)//正向冒泡，找出最大值 
        {
            if(a[j]>a[j+1])
            {
                swap=a[j];
                a[j]=a[j+1];
                a[j+1]=swap;
            } 
        }
            right--; //前移一位
        for(int j=right;j>left;j--)//反向冒泡找出最小值 
        {
            if(a[j-1]>a[j])
            {
                swap=a[j];
                a[j]=a[j-1];
                a[j-1]=swap;
            }
        }
        left++; //修改left值。后移一位 
    }
}
int main()
{
    int a[]={7,8,4,2,9,5,6,1,3};
    int n=sizeof(a)/sizeof(int);
    BuddleSort(a,n);
     printf("鸡尾酒排序结果：");
    for (int i = 0; i < n; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
    return 0;
 } 

 选择排序(SelectSort)

选择排序是一种简单直观的排序算法，工作原理为：在未排序的序列中找出最小(大)元素与第一个位置的元素交换位置

注意选择排序与冒泡排序的区别：冒泡排序通过依次交换相邻两个顺序不合法的元素位置，从而将当前最小（大）元素放到合适的位置；而选择排序每遍历一次都记住了当前最小（大）元素的位置，最后仅需一次交换操作即可将其放到合适的位置。

然后在剩下的元素中再找最小(大)元素与第二个元素的位置交换，依此类推，直到所有元素排序排序完成。根据上述描述，一共进行n-1趟比较后，就能完成整个排队过程。我们可以知道，第k趟比较需要进行的数组元素的两两比较的次数为n-k次，所以共需要的比较次数为n*(n-1) / 2，因此选择排序算法的时间复杂度与冒泡排序一样，也为O(n^2)。

算法简介：

     1.初始状态：序列为无序状态。

     2.第1次排序：从n个元素中找出最小(大)元素与第1个记录交换

     3.第2次排序：从n-1个元素中找出最小(大)元素与第2个记录交换

     4.第i次排序：从n-i+1个元素中找出最小(大)元素与第i个记录交换

    5.以此类推直到排序完成

动画演示：

代码如下

#include<stdio.h>
void SelectSort(int a[],int n)
{
    for(int i=0;i<n-1;i++)
    {
        int min=i;  //存放数组最小值的位置 
        
        for(int j=i+1;j<n;j++)
        {
            if(a[j]<a[min]){
                min=j;   //找出最小值，并记录位置 
            }
         } 
         if(min!=i) //最小元素与第i个元素互换位置 
         {
            int swap=a[min];
             a[min]=a[i];
             a[i]=swap;
         }
    }
}
int main()
{
    int a[]={8,9,7,1,5,4,2,3,6};
    int n=sizeof(a)/sizeof(int);
    SelectSort(a,n);
     printf("选择排序结果：");
    for (int i = 0; i < n; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
    return 0;
}

 插入排序(InsertSort)

插入排序是一种简单直观的排序算法，工作原理为构建有序序列，对于未排序元素，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间，直到排序完成，如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。理解了插入排序的思想后，我们便能够得到它的时间复杂度。对于n个元素，一共需要进行n-1轮比较，而第k轮比较需要进行k次数组元素的两两比较，因此共需要进行的比较次数为：1 + 2 + ... + (n-1)，所以插入排序的时间复杂度同冒泡排序一样，也为O(n^2)。

算法简介：

     1.从第一个元素开始，该元素可认为已排序。

     2.取出下一个元素，在排序好的元素序列中从后往前扫描

     3.如果元素(已排序)大于新元素，将该元素移到下一位置

     4.重复3.直到找到已排序的元素小于或等于新元素的位置

     5.将新元素插入该位置后

     6.重复2-5直到排序完成

动画演示：

代码如下

#include<stdio.h>
void InsertSort(int a[],int n)
{
    for(int i=0;i<n;i++)
    {
        int j=i-1;
        if(a[i]<a[i-1]){ //若第i个元素小于第i-1个元素,移动有序序列插入------大于的话则直接插入 
        int swap=a[i];  //存储将要排序的元素 
        a[i]=a[i-1];   //向后移动一个元素 
        while(swap<a[j])//查询将要插入的位置 
        {
            a[j+1]=a[j];
            j--;       //元素后移 
        }
        a[j+1]=swap;//循环结束 插入到指定位置 
    }    
    }
}
int main() {
    int a[] = { 9,7,8,2,5,1,3,6,4};
    int n = sizeof(a)/sizeof(int);
    InsertSort(a, n);
    printf("排序好的数组为：");
    for (int i = 0; i < n; i++) {
        printf(" %d", a[i]);
    }
    printf("\n");
    return 0;
}

还有几种经典的排序算法没有写出，后续将补充，有不足之处还请指出。谢谢