##排序的代码及注释##

• 冒泡排序（BubbleSort）

• 概念：冒泡排序呢，是咱们几个排序里面最基本的一个排序。在排序的过程中，两个相邻的数进行比较，将最大或者最小的一个元素放到咱们数组的最后面，重复进行比较工作，直到没有相邻的数可以交换，那么该排序就已经完成。

• 特点：冒泡排序具有稳定性，最多执行n(n-1)/2次

• 冒泡排序的演示过程如下图所示：

• 代码：—— 从小到大排序

int subbleSort(int arr[],int len){
    int i,j,temp;    //i  内层循环下标  j 外层循环下标  temp  相当于一个容器，用于交换
    //外层控制元素 —— 比较一共要进行多少趟
    for(i=0;i<len-1;i++){  
        //内层控制元素 —— 一趟比较的次数
        for(j=0;j<len-i-1;j++){
            if(arr[j+1]<arr[j]{  //如果后面的数小于前面的数，那就进行交换
                temp = arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }

    //输出元素
    printf("冒泡排序后的结果为：");
    for(i=0;i<len;i++){
       printf("%d ",arr[i]);
    }
}
int main(){
    int arr[10];
    int i,len=sizeof(arr)/sizeof(int);  //sizeof(arr)/sizeof(int)  数组长度
    for(i=0;i<len;i++){
        printf("请输入第%d个元素",i+1);
        scanf("%d",&arr[i]);            //键盘录入元素
    }
    
    //调用冒泡排序函数
    subbleSort(arr,len);
}

• 选择排序（SelectSort）

• 概念：选择排序是一种简单直观的排序算法。首先在未排序的序列中找到最小或者最大值，存放到排序序列的首位置，再从剩余未排序的元素中，继续寻找最大或者最小放到已排序的序列的末尾。直到排序结束。

• 特点：选择排序具有不稳定性，平均比较次数n(n-1)/2次

• 选择排序的演示过程如下图所示：

• 代码：—— 从小到大

void selectSort(int arr[] , int len){
    
    int i,j,temp,min;  // i 第一个数的下标范围；j  第二个数的下标范围；temp  中间变量
    //min  存放最小值的下标
    
    for(i=0;i<len;i++){
        min=i;          //min 标记 未排序第一个元素的位置
        
        for(j=i+1;j<len;j++){      //找 比 min 位置还小的元素
            
            if(arr[j]<arr[min]){   //如果这个数比最小值还小
                min=j;             //那就把j下标给最小值
            }
        }
        //如果最小值下标不是本轮第一个数，进行交换 
        if(min!=i){
             temp =arr[min];
             arr[min]=arr[i];
             arr[i]=temp;  
        }
    }
    //输出元素
    printf("选择排序后的结果为：");
    for(i=0;i<len;i++){
       printf("%d ",arr[i]);
    }
}

int main(){
    int arr[10];
    int i,len=sizeof(arr)/sizeof(int);  //sizeof(arr)/sizeof(int)  数组长度
    for(i=0;i<len;i++){
        printf("请输入第%d个元素",i+1);
        scanf("%d",&arr[i]);            //键盘录入元素
    }
    
    //调用选择排序函数
    selectSort(arr,len);
}

• 直接插入排序（insertSort）

• 概念：每一趟将一个待排序的记录，按其关键字的大小插入到已经排好序的一组记录的适当位置上，直到所有待排序记录全部插入为止。

• 特点：直接插入排序，是在有序的基础上，速度最快且稳定的排序方法

• 直接插入排序 演示图如下：

• 代码：—— 从小到大

void insertSort(int arr[], int len){
    
    int i, j, temp;
    for(i=1;i<len;i++){   //插入数据的下标范围 
        if(arr[i]<arr[i-1]){  //如果插入数据比前面数据小，进行交换 
            temp=arr[i];      //把要插入的数据放入t中 
            for(j=i-1;j>=0 && temp<arr[j];j--){  //前面所有比插入数据大的数往后移 
                arr[j+1]=arr[j];//后移 
            }
            a[j+1]=temp;  //把要插入的数据放到空位置 
        }
    //输出元素
    printf("直接插入排序后的结果为：");
    for(i=0;i<len;i++){
       printf("%d ",arr[i]);
    }
}

int main(){
    int arr[10];
    int i,len=sizeof(arr)/sizeof(int);  //sizeof(arr)/sizeof(int)  数组长度
    for(i=0;i<len;i++){
        printf("请输入第%d个元素",i+1);
        scanf("%d",&arr[i]);            //键盘录入元素
    }
    
    //调用直接插入排序函数
    insertSort(arr,len);
}

• 希尔排序（shellInsert）

• 概念：希尔排序的思想跟插入排序差不多，但是希尔排序是按照 步长 进行分组，然后对每一组的第几个元素进行排序（增量就是步长）

• 特点：希尔排序具有不稳定性

• 希尔排序演示图 如图下所示：

• 代码：—— 从小到大

//增量及步长
void shellInsert(int arr[], int len, int dk){
    int i, j, temp;   //i 循环变量  j 前边组的位置  temp 临时变量    
    for(i = dk; i < len; i++){
        //判断每组的 第几个元素大小
        if(arr[i] < arr[i-dk]){   //后边组 小于 前边组
            temp = arr[i];             
            for(j = i-dk; j>=0 && arr[j] > temp; j = j-dk){
                //前边的值 给到 后边
                arr[j+dk] = arr[j];
            }
            arr[j+dk] = temp;
        }
    }
    //输出元素
    printf("希尔排序后的结果为：");
    for(i=0;i<len;i++){
        printf("%d ",arr[i]);
    }
}

int main(){
    int arr[10];
    int i,len=sizeof(arr)/sizeof(int);  //sizeof(arr)/sizeof(int)  数组长度
    for(i=0;i<len;i++){
        printf("请输入第%d个元素",i+1);
        scanf("%d",&arr[i]);            //键盘录入元素
    }

    int t[]={5,2,1};      //循环增量
    int e,dk;
    for(e=0;e<3;e++){     //循环3次，每次取出增量
         dk=t[e];          //循环取出增量
    } 
    //调用希尔排序函数
    shellSort(arr,len,dk);
}

• 快速排序（quickSort）

• 概念：快速排序是通过比较和交换位置来排序的排序算法，是对冒泡算法的一种优化。从所有数据中取一个基准值。i 从前向后找，比基准值大的元素 j 从后向前找，比基准值小的元素，最后，结束的条件是 i=j 此时将 基准值放到这个位置

• 特点：快速排序具有不稳定性，空间复杂度为O(logN)

• 快速排序 演示图如下：

• 代码：—— 从小到大

int quickSort(int arr[],int len,int low,int high){
    int i,j;
    int pivot=arr[low];   //把第一个数当成基准值（头部空）
    //腾位置
    while(low<high){
        
        while(low<high&&arr[high]>=pivot){  //尾部数据>基准值 数据不动，wei--
            high--;
        }
        arr[low]=arr[high];     //尾部数据放到前面（尾部空）
        while(low<high&&arr[low]<=pivot){    //前面数据< 基准值   数据不动   tou++
            low++;
        }
        arr[high]=arr[low];
    }
    arr[low]=pivot;    //把数据放入空的该位置（此时tou=wei)
    return low;        //返回基准值所在的位置 
    

}

int fun(int arr[],int len,int low,int high){
    if(low<high){
        int pivot = quickSort(arr,len,low,high);
        //利用递归，对你已经分过区的左半部分 在分区
        fun(arr,len,low,pivot-1);
        //利用递归，对你已经分过区的右半部分在分区
        fun(arr,len,pivot+1,high);
    }
}

int main(){
    int arr[10];
    int i,len=sizeof(arr)/sizeof(int);
    for(i=0;i<len;i++){
        printf("请输入第%d个元素：",i+1);
        scanf("%d",&arr[i]);
    }
    int low=0,high=9;
    //递归函数--传过去相关数据
    fun(arr,len,low,high);
    
    printf("快速排序后的结果为：");
    for(i=0;i<len;i++){
        printf("%d ",arr[i]);
    } 
}