三种java排序算法（冒泡排序、快速排序、插入排序）

1.快速排序

原理：快速排序原理即是，选择数组中的一个元素作为基准值 ，然后遍历其他元素，将小于基准值 的元素放置在左边，将大于基准值的元素放置在右边。如是你可以得到两个子数组，再依次对子数组进行快速排序，最终完成排序。

时间复杂度： 快速排序比选择排序快得多，其时间复杂度为 O(n * lg n)，是最快的排序算法之一。最糟糕的情况下，快速排序的时间复杂度为 O(n^2)。

代码实现：

public static void main(String[] args) {
        int[] arr = new int[]{5,45,18,6,35,24,7,45,8,21};
        qSort(arr,0,arr.length-1);
        printList(arr);
    }
    public static void qSort(int[] arr,int start,int end){
        if(end <= start){
            return;
        }
        int low = start;
        int high = end;
        int value = arr[low];
        while(low < high){
            while(low < high && arr[high] >= value){
                high--;
            }
            arr[low] = arr[high];
            while(low < high && arr[low] <=value ){
                low++;
            }
            arr[high] = arr[low];
        }
        arr[low] = value;
        qSort(arr,start,low-1);
        qSort(arr,low+1,end);
    }
    public static void printList(int[] arr){
        for(int i =0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }

结果：

2.冒泡排序

原理： 对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组的前面（从小到大排序），把大的元素移动到数组的后面，即交换两个元素的位置，这样较小的元素就像气泡一样从底部上升到顶部。

时间复杂度：
冒泡排序一共要进行(n-1)次循环,每一次循环都要进行当前n-1次比较
所以一共的比较次数是: (n-1) + (n-2) + (n-3) + … + 1 = n*(n-1)/2;
所以冒泡排序的时间复杂度是 O(n^2)

代码实现：

public static void main(String[] args) {
        int[] arr = new int[]{15,8,38,42,15,35,2,48,37,18,7};
        mSort(arr);
        printList(arr);
    }
    public static void mSort(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            for(int j=i+1;j<arr.length;j++){
                if (arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }
    public static void printList(int[] arr){
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }

结果：

3.直接插入排序

原理： 在一个数组中，将第一个元素看作排序元素序列里的唯一元素，然后申请一个空间出来，首先存放第二元素,即可在数组中空第二个元素位置（即此位置可被覆盖），将第二个元素与有序序列里面唯一一个元素进行比较，根据排序条件决定元素交换与否，然后有序序列元素加一，申请空间里面存放将要插进有序序列里面的元素；

时间复杂度： 时间复杂度为O（n^2） 元素移动是顺序的 所以为稳定排序

代码实现：

public static void main(String[] args) {
        int[] arr = new int[]{31,8,38,42,15,35,2,48,37,18,7};
        mSort(arr);
        printList(arr);
    }
    public static void mSort(int[] arr){
        for(int j = 1; j < arr.length; j++) {
            int key = arr[j];
            int i = j -1;
            while(i >= 0 && arr[i] > key){
                arr[i + 1] = arr[i];
                i--;
            }
            arr[i + 1] = key;
        }
    }
    public static void printList(int[] arr){
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }

结果：