几种常用的排序算法总结

几种常用的算法的时间空间复杂度

1、冒泡排序
思想：比较相邻的元素，如果第一个元素比第二个大，就交换位置，对每一对相邻的元素进行同样的操作。这样最后的元素应该是最大的数。排除最后一个数，针对前面的所有元素进行上述步骤，持续每次在越来越少的元素中找到最大。
算法 Java代码：

    static void popSort(int[] a){
        for(int i = 0; i < a.length-1; i++){
            for(int j = i+1; j < a.length; j++){
                if(a[i]>a[j]){
                    var temp = a[i];
                        a[i] = a[j];
                        a[j] = temp;
                }
            }
        }
    }
最后循环打印输出数组。

注意if中的代码，是经常用到的交换两个元素的位置的常用方法。

2、快速排序
思想：采用分治的策略，从数组选出一个数作为基准。分区过程，将比这个数大的数放在它的右边，比它小的数放在它的左边。再对左右空间重复上述，知道各区间只有一个元素。
快排是一种不稳定的排序。
算法 代码：

  static void quickSort(int[] a, int l, int r){
    if(l < r){
        int i = l, j = r, x = a[l];
        while(i < j){
            while(i < j && a[j] > x)     j--;
            if(i < j)     a[i++] = a[j];
            while(i < j && a[i] < x)     i++;
            if(i < j)     a[j--] = a[i];
        }
        a[i] = x;
        quickSort(a,l,i-1);
        quickSort(a,i+1,r);
    }
}

3、选择排序
思想：从数据中选择一个最小的与第一个值交换，再从剩下的部分找出最小的与第二个交换，以此类推。。。
算法代码 ：

static void selectSort(int [] a){
    int minIndex = 0, temp = 0;
    //minIndex保存最小下标。temp是用于连个元素进行交换的临时变量
    for(int i = 0; i< a.length-1; i++){
        minIndex = i;

        for(int j = i+1; j < a.length; j++){
            if(a[j] < a[minIndex])
                minIndex = j;
        }
        if(minIndex != i){
            temp = a[minIndex];
            a[minIndex] = a[i];
            a[i] = temp;
        }
    }
}　

4、直接插入排序
思想：
1. 插入排序， 从第二个数开始，先将第二个数做一个副本放在一旁（变量中）。
2 .第二个数同前一个数比较，小于则用前一个数覆盖第二个数， 然后将副本放在前一个数前面
3. 再将第三个数做一个副本取出，第三个数同前一个数比较，小于则用前一个数覆盖第三个数（此时第二个数位置空闲）， 然后用副本同前一个数的前一个数比较，如果小于，则用前一个数的前一个数覆盖在原本的第二个位置上（此时第一个位置空闲）， 将副本放入即可。
4. 将数组中接下来的数依次做与3类似步骤，以3类推将副本往前作比较。直到副本不小于比较的数则该轮插入结束
5. 重复4步骤，直到最后一个数

    public static void insert_Sort(int[] a){
        int temp;//设置一个临时变量，存放即将要插入的数。
        for(int i = 1; i < a.length; i ++){

            for(int j = i; j > 0; j --){

                if(a[j]< a[j-1]){

                    temp = a[j];
                    a[j] = a[j-1];
                    a[j-1] = temp;
        //这几行代码是常用的将两个元素进行位置交换的方法
                }
            }
        }

5、归并排序
思路:
将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。如何让这二组组内数据有序了？

可以将A，B组各自再分成二组。依次类推，当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序。

设两个有序的子序列(相当于输入序列)放在同一序列中相邻的位置上：array[low..m]，array[m + 1..high]，先将它们合并到一个局部的暂存序列 temp (相当于输出序列)中，待合并完成后将 temp 复制回 array[low..high]中，从而完成排序。

//二路归并排序就是先将一个数组一半一半的分成若干个有序的数组，再进行组合
    static void mergearray(int a[], int first, int mid, int last, int temp[])  
    {  
        int i = first, j = mid + 1;  
        int m = mid,   n = last;  
        int k = 0; 
        while (i <= m && j <= n)  
        {  
            if (a[i] <= a[j])  
                temp[k++] = a[i++];  
            else  
                temp[k++] = a[j++];  
        } 
        while (i <= m)  
            temp[k++] = a[i++];  
       while (j <= n)  
            temp[k++] = a[j++];  
      //将临时数组temp中的值复制到原来的数组中
        for (i = 0; i < k; i++)  
            a[first + i] = temp[i];  
    }  
    //将数组进行多次划分，再进行合并排序
    static void mergesort(int a[], int first, int last, int temp[])  
    {  
        if (first < last)  
        {  
            int mid = (first + last) / 2;  
            mergesort(a, first, mid, temp);    //左边有序  
            mergesort(a, mid + 1, last, temp); //右边有序  
            mergearray(a, first, mid, last, temp); //再将二个有序数列合并  
        }  
    }  
    static Boolean MergeSort(int a[], int n)  
    {  
        int [] temp= new int[n];  
        if (temp == null)  
            return false;  
        mergesort(a, 0, n - 1, temp);   
        return true;  
    }