6大排序方法（你不会后悔点进来）

1.冒泡排序
我们直接看例子
假设有5个数：
5 4 3 2 1
我们要将它按从小到大的顺序排列，正常的思维我们会这么做

5 4 3 2 1
4 5 3 2 1
4 3 5 2 1
3 4 5 2 1
3 4 2 5 1
…
一次比较相邻的2个数，将小的换到前面
平均复杂度O(n^2)

class sort{

   static void onesort(int a[]){//要排序的数组
        boolean flag=true;//判断交换是否还需要继续进行
        while (flag) {
            flag=false;
            for (int i = 1; i < a.length-1;i++) {
                if(a[i]>a[i+1]){
                    int x=a[i];
                    a[i]=a[i+1];
                    a[i+1]=x;
                    flag=true;//因为开始我们已经改成了false，如果没有可进行交换的flag就会是false  函数也就不会继续进行，这样会大大节省时间
                }


            }
        }
    }
}

---

2.选择排序
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

重复第二步，直到所有元素均排序完毕

还是这个例子：

5 4 3 2 1
1 4 3 2 5
1 2 3 4 5
平均复杂度O(n^2)

void swap(int *a,int *b) //交换函数
{
    int temp = *a;
    *a = *b;
    *b = temp;
}
void selection_sort(int arr[], int len)
{
    int i,j;

        for (i = 0 ; i < len - 1 ; i++)
    {
                int min = i;
                for (j = i + 1; j < len; j++)     //遍历剩余未排序元素
                        if (arr[j] < arr[min])    //找到目前最小值
                                min = j;    //记录最小值
                swap(&arr[min], &arr[i]);    //做交換
        }
}

通常选择排序优于冒泡排序，冒泡排序在内循环交换，选择排序在外循环交换，效率差也就在这个交换次数上，毕竟O(n)<O(n^2)。如果数组完全有序，冒泡内循环的交换一次都不会执行，而选择排序每次还要和本身交换一次，此时冒泡效率高。但这种情况极少，所以丼从算法的角度看，选择优于冒泡

---

3.插入排序
在要排序的一组数中，假定前n-1个数已经排好序，现在将第n个数插到前面的有序数列中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。

例子如下：
5 4 3 2 1
从第二个数开始插入
5 4 未排序 ：3 2 1
因为4比5小 ，插入到5的前面
4 5 未排序 ：3 2 1
3 4 5 未排序 ：2 1
…

public static void  insert_sort(int array[],int lenth){

   int temp;

   for(int i=0;i<lenth-1;i++){
       for(int j=i+1;j>0;j--){
           if(array[j] < array[j-1]){
               temp = array[j-1];
               array[j-1] = array[j];
               array[j] = temp;
           }else{         //不需要交换
               break;
           }
       }
   }
}

---

4.希尔排序
希尔排序可以认为是加强版的插入排序，它利用插入排序在数据量较小时和数据相对有序时的高效性，将一个数组在逻辑上按下标相隔距离进行分组，然后对每个组进行插入排序

public static void shell_sort(int array[],int lenth){

   int temp = 0;
   int incre = lenth;

   while(true){
       incre = incre/2;

       for(int k = 0;k<incre;k++){    //根据增量分为若干子序列

           for(int i=k+incre;i<lenth;i+=incre){//当incre（也就是k）确定时，因为至少要2个元素才能进行插入排序，所以要插入的元素从k+incre开始枚举（第一个元素下标为k）

               for(int j=i;j>k;j-=incre){//依次用要插入的元素和前一个元素做比较
                   if(array[j]<array[j-incre]){//比它小就交换，例如往 3 5 7 中插入4  
                                               /*3 5 4 7
                                               	 3 4 5 7
                                               */
                       temp = array[j-incre];
                       array[j-incre] = array[j];
                       array[j] = temp;
                   }else{
                       break;//无法交换就退出
                   }
               }
           }
       }

       if(incre == 1){
           break;//当incre为1时  整个数列分为了一组，进行插入排序一定是有序的故直接退出while
       }
   }
}

---

5.归并排序
归并排序的核心思想是分治，说的直白点就是将需要排序的数组分成很多小的数组进行排序，它和快速排序有异曲同工之妙
（图片来自知乎）

图中我们对未排序的数列进行分割，直到分割成一个一个的数据，再把这些数据两两归并到一起，使之有序，不停的归并，最后成为一个排好序的序列。

static void merge_sort_recursive(int[] arr, int[] result, int start, int end) {
    if (start >= end)//正常情况开头是大于结尾的，除非已经分割成单个元素，则此时返回
        return;
    int len = end - start, mid = (len >> 1) + start;//len >> 1位运算，相当于除2
    //找出当前数列中间的位置
    int start1 = start, end1 = mid;//分割成2个数列
    int start2 = mid + 1, end2 = end;
    merge_sort_recursive(arr, result, start1, end1);//递归下去，对2个子序列排序
    merge_sort_recursive(arr, result, start2, end2);
    //经过上面的递归，start1~end1  ，start2~end2已经是有序的了
    int k = start;
    while (start1 <= end1 && start2 <= end2)
        result[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];//从2个有序的里面选出小的
        /*1 4 7 8 9
          2 3 5 
          第一个选1
          第二个选2 
          第三个选3
          .... 
		*/
        
    while (start1 <= end1)//因为start1 <= end1 && start2 <= end2  中 有一个条件会先不满足，那么存在一个满足仍然是满足的，说明有元素没有赋值到 result数组，所以要加上
        result[k++] = arr[start1++];
    while (start2 <= end2)
        result[k++] = arr[start2++];
    for (k = start; k <= end; k++)
        arr[k] = result[k];
}

public static void merge_sort(int[] arr) {
    int len = arr.length;
    int[] result = new int[len];
    merge_sort_recursive(arr, result, 0, len - 1);
}

6.快速排序（图片来自啊哈算法）
应该是用的最多的吧，很多语言stl里的排序算法基本用的都是快速排序，上面我们说它和归并排序有异曲同工之妙，但也有差别；
区别：
进行分组的策略不同，合并的策略也不同。归并的分组策略：是假设待排序的元素存放在数组中，那么把数组前面的一半元素作为一组，后面一半作为另一组。而快速排序则是根据元素的值来分的，大于某个值的元素一组，小于某个值的元素一组。
快速排序在分组的时候已经根据元素的大小来分组了，而合并时，只需要把两个分组合并起来就可以了，归并排序则需要对两个有序的数组根据大小合并；

现在我们先看看快速排序怎么操作；

1.所先我们需要设定一个基数，作为分割点，一般我们选取数组最左边的数；

2.有了基数后，我们分别从左到右，从右到左遍历数组，记住是同时进行的

3.直到找到一个小于基数的数，和大于基数的数，然后我们对其进行交换；

（反复执行了很多次3操作）

4.如图所示，当2个兵兵碰头后，这个数组也就遍历完了

此时6（基数）比3大，我们就对齐进行交换

此时6左边都是小于6的数，右边都是大于6的数，然后将这2块分成2个数组递归下去，直到递归为一个大小为2的数组

然后我们合并这些数组就能得到有序的数组了；

blic class QuickSort {
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        int[] arr=new int[10];
        for(int i=0;i<10;i++){
            arr[i]=scan.nextInt();
        }
        QuickSort(arr, 0, arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

    }
    public static void QuickSort(int[] arr,int low,int high){
        int i,j,temp,t;
        if(low>high){
            return;
        }
        i=low;
        j=high;
        //temp就是基准位
        temp = arr[low];

        while (i<j) {
            //先看右边，依次往左递减
            while (temp<=arr[j]&&i<j) {
                j--;
            }
            //再看左边，依次往右递增
            while (temp>=arr[i]&&i<j) {
                i++;
            }
            //如果满足条件则交换
            if (i<j) {
                t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }

        }
        //最后将基准为与i和j相等位置的数字交换
        arr[low] = arr[i];
        arr[i] = temp;
        //递归调用左半数组
        QuickSort(arr, low, j-1);
        //递归调用右半数组
        QuickSort(arr, j+1, high);
    }
}