常见的排序算法实现和分析

一、冒泡排序

1.算法原理：

• 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
• 针对所有的元素重复以上的步骤，除了最后一个。
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 

2.代码实现：

package SortDemo;

/**
 * on 2018/4/8.
 */
public class bubbleSort {
    public static void main(String[] args) {
        int[] a= new int[]{1,5,6,12,9,4,3,9,6};
        print(a);
        bubbleSORT(a);
        print(a);
    }

    public static void bubbleSORT(int[] a){
        int temp;
        for(int i =0;i<a.length;i++){
            for(int j =0;j<a.length-i-1;j++){
                if(a[j]>a[j+1]){
                    temp =a[j];
                    a[j]= a[j+1];
                    a[j+1] =temp;
                }
            }
        }
    }

    public static void print(int[] a){
        for (int i: a
             ) {
            System.out.print(i+" ");
        }
        System.out.println();
    }
}

3.代码改进：

   因为当某次循环中没有任何元素发生位置上的改变时，说明该数组已经有序，那么就不需要再次进行后面的循环。如下（注意加粗）：

    public static void bubbleSORT(int[] a){
        int temp;
        boolean flag =true;
        for(int i =0;i<a.length&&flag;i++){
            //每次循环初始化为false
            flag = false;
            for(int j =0;j<a.length-i-1;j++){
                if(a[j]>a[j+1]){
                    temp =a[j];
                    a[j]= a[j+1];
                    a[j+1] =temp;
                    //若发生过交换则修改该标记为true,以便能够进行下次循环
                    flag = true;
                }
            }
        }
    }

4.时间复杂度：    

二、快速排序

1.算法原理

• 采用二分的思想，先从数列中取出一个数作为基准数；
• 将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边；
• 再对左右区间重复第二步，直到各区间只有一个数

2.代码实现

package SortDemo;

import java.util.Arrays;

/**
 *  on 2018/4/8.
 */
public class quickSort{

    public static void main(String[] args) {
        int[] a= new int[]{1,5,6,12,9,4,3,9,6,10,21,16};
        //用这个方法输出数组蛮方便的~        
        System.out.println(Arrays.toString(a));
        quick(a,0,a.length-1);
        System.out.println(Arrays.toString(a));
    }

    public static void quick(int[] a,int low ,int high){
        if (low<high){
            int index = getIndex(a,low,high);
            quick(a,low,index-1);
            quick(a,index+1,high);
        }
    }

    private static int getIndex(int[] a, int low, int high) {
        int key =a[low];
        while(low<high){
            while(a[high]>=key&&low<high)
                high--;
            a[low]=a[high];
            while(a[low]<=key&&low<high)
                low++;
            a[high]=a[low];
        }
        a[high]=key;
        return high;
    }
}

3.平均时间复杂度：  O(N*logN)

三、直接插入排序

1.算法原理：

• 在要排序的一组数中，假设前面(n-1)个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。
• 如此反复循环，直到全部排好顺序

2.代码实现：

package SortDemo;

import java.util.Arrays;

/**
 *  on 2018/5/2.
 */
public class insertSort {
    public static void main(String[] args) {
        int[] a= new int[]{1,5,6,12,9,4,3,9,6,10,21,16};
        System.out.println(Arrays.toString(a));
        InsertSort(a);
        System.out.println(Arrays.toString(a));
    }

    public static void InsertSort(int[] a){
        for(int i=1;i<a.length;i++){
            int j;
            //待插入元素
            int x=a[i];
            for(j=i;j>0 && x<a[j-1];j--){
                //比X大的逐个后移一位
                a[j]=a[j-1];
            }
            a[j]=x;
        }
    }
}

3.平均时间复杂度：  

四、简单选择排序

1.算法原理：

• 在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；
• 然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换;
• 依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

2.代码实现：

package SortDemo;

import java.util.Arrays;

/**
 * on 2018/5/2.
 */
public class simpleSelectSort {
    public static void main(String[] args) {
        int[] a= new int[]{1,5,6,12,9,4,3,9,6,10,21,16};
        System.out.println(Arrays.toString(a));
        SimpleSelectSort(a);
        System.out.println(Arrays.toString(a));
    }

    private static void SimpleSelectSort(int[] a) {
        int temp;
        for(int i =0;i<a.length;i++){
            //记录最小的数的下标
            int min = i;
            for(int j = i+1;j<a.length;j++){
                if(a[j]<a[min]){
                    //更新下标
                    min= j;
                }
            }
            //将剩余n-i个数里最小的数更新为a[i]
            temp =a[i];
            a[i] = a[min];
            a[min] =temp;
        }
    }
}

3.平均时间复杂度：