排序：冒泡 vs 快排

冒泡：

代码：public static void main(String[] args) {
    int[] arr = {1,5,3,8,4,9,5,5,6,7,2,88,54,666,47};
    for (int i = 0;i <arr.length;i++){
        for (int j = 0;j <arr.length-i-1;j++){
            if(arr[j]>arr[j+1]){
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }

    }

    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i]+",");
    }
}

运行结果：

相对于简单选择排序，冒泡排序交换次数明显更多。它是通过不断地交换把最大的数冒出来。冒泡排序平均时间和最坏情况下（逆序）时间为o（n^2）。最佳情况下虽然不用交换，但比较的次数没有减少，时间复杂度仍为o（n^2）。此外冒泡排序是稳定的

快排：快速排序是冒泡排序的一种改进，冒泡排序排完一趟是最大值冒出来了，那么可不可以先选定一个值，然后扫描待排序序列，把小于该值的记录和大于该值的记录分成两个单独的序列，然后分别对这两个序列进行上述操作。这就是快速排序，我们把选定的那个值称为枢纽值，如果枢纽值为序列中的最大值，那么一趟快速排序就变成了一趟冒泡排序。

public static void main(String[] args) {
    int[] arr = {1,5,3,8,4,9,5,5,6,7,2,88,54,666};
    quickSort(arr);


    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i]+",");
    }
}
public static void quickSort(int[] arr){
    qsort(arr, 0, arr.length-1);
}
private static void qsort(int[] arr, int low, int high){
    if (low < high){
        int pivot=partition(arr, low, high);        //将数组分为两部分
        qsort(arr, low, pivot-1);                   //递归排序左子数组
        qsort(arr, pivot+1, high);                  //递归排序右子数组
    }
}
private static int partition(int[] arr, int low, int high){
    int pivot = arr[low];     //枢轴记录
    while (low<high){
        while (low<high && arr[high]>=pivot) --high;
        arr[low]=arr[high];             //交换比枢轴小的记录到左端
        while (low<high && arr[low]<=pivot) ++low;
        arr[high] = arr[low];           //交换比枢轴小的记录到右端
    }
    //扫描完成，枢轴到位
    arr[low] = pivot;
    //返回的是枢轴的位置
    return low;
}