冒牌排序 快速排序 java 快速实现

package com.robot.boot;

import java.util.Arrays;

/**
 * Created by Administrator on 2018-11-06.
 */
public class TestMethod {
    public static void main(String[] args) {
        int[] arr = {24, 46, 89, 41, 27, 63, 58, 41, 89};
//        System.out.println( bubblingArray(arr)); //冒泡排序

        //快速排序
      int start = 0;
        int end = arr.length - 1;
        fastSort(arr, start, end);
        System.out.println(Arrays.toString(arr));


    }

    /**
     * 冒泡排序
     * 实现简单，但是运算复杂
     *
     * @param arr
     * @return
     */
    public static void bubblingArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - 1; j++) {
                int temp = 0;
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

    /**快速排序
     *    利用递归，从中1分为2，小的放左边 大的放右边
     *
     * @param a    数组
     * @param low  开始位置
     * @param high 结束位置
     */
    public static void fastSort(int[] a, int low, int high) {
        int start = low;
        int end = high;
        int key = a[low];   //基准数
        while (end > start) {
            //从后往前比较
            while (end > start && a[end] >= key)
                //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
                end--;
            if (a[end] <= key) {
                int temp = a[end];
                a[end] = a[start];
                a[start] = temp;
            }
            //从前往后比较
            while (end > start && a[start] <= key)
                //如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
                start++;
            if (a[start] >= key) {
                int temp = a[start];
                a[start] = a[end];
                a[end] = temp;
            }
            //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
        }
        //递归
        if (start > low) fastSort(a, low, start - 1);//左边序列。第一个索引位置到关键值索引-1
        if (end < high) fastSort(a, end + 1, high);//右边序列。从关键值索引+1到最后一个
    }
}

冒牌排序的时间复杂度 Bubble Sort：

时间复杂度  O（n²）   冒泡排序最好的时间复杂度为