冒泡排序+快速排序

一.冒泡排序：

外层循环控制排序躺数：n个数需要跑n-1躺，一个数组的长度为length，那么下标为length-1，那么最大趟数为length-2，即写为<length-1  //因为比较剩下最后一个数时，无需比较。

内层循环控制每一趟的比较次数：每一趟需要比较n-i次

/*
 * 冒泡排序
 */
public class BubbleSort {
　　public static void main(String[] args) {
　　　　int[] arr={6,3,8,2,9,1};
　　　　System.out.println("排序前数组为：");
　　　　for(int num:arr){
　　　　　　System.out.print(num+" ");
　　　　}
　　　　for(int i=0;i<arr.length-1;i++){//外层循环控制排序趟数
　　　　　　for(int j=0;j<arr.length-1-i;j++){//内层循环控制每一趟排序多少次
　　　　　　　　if(arr[j]>arr[j+1]){
　　　　　　　　　　int temp=arr[j];
　　　　　　　　　　arr[j]=arr[j+1];
　　　　　　　　　　arr[j+1]=temp;
　　　　　　　　}
　　　　　　}
　　　　} 
　　　　System.out.println();
　　　　System.out.println("排序后的数组为：");
 　　　　for(int num:arr){
 　　　　　　System.out.print(num+" ");
 　　　　} 
　　}
 }

二.快速排序：

  快速排序，顾名思义，是一种速度快，效率高的排序算法。
快排原理：
        在数组中选择一个Base值，通过一趟排序将数组分成两部分，其中以Base为中心，Base右边都比Base大，Base左边的都Base小，然后对左右两部分重复这个过程，不停分割区间，直到左右下标出界(i>j)，可以得到有序数组。

1，定义i=0，j=数组.lenght-1，i为第一个数的下标，j为最后一个数下标
2，数组从右往左找，找到第一小于Base的数，记录下标J；
3，数组从左往右找，找到第一个大于Base的数，记录下标为I；
4，交换俩下标值；
5，重复这个过程，直到 i=j（两个哨兵碰面）
6，调整Base的位置，把数组[i]的值 （也就是哨兵碰面的index对应的值）和Base（初始的值）交换
假设要排的数组为：A[8] ={ 5 2 8 9 2 3 4 9 }
           选择 key = 5， 开始时 i=0，j=7

开始：       5    2    8    9    2    3    4    9
                i                                        j  
第一次找   5    2    8    9    2    3    4    9
                            i                       j
交换：       5    2    4    9    2    3    8    9 
                            i                       j
第二次找   5    2    4    9    2    3    8    9
                                  i           j
交换：       5    2    4    3    2    9    8    9
                                  i            j
第三次找    5    2    4    3    2    9    8    9
                                       ij   
调整key： 2    2    4    3    5    9    8    9
                                        ij

以下为代码：public class QuickSort {

public static void main(String[] args) {
        int[] a = {1, 2, 4, 5, 7, 4, 5 ,3 ,9 ,0};
        System.out.println(Arrays.toString(a));
        quickSort(a);
        System.out.println(Arrays.toString(a));
    }

    public static void quickSort(int[] a) {
        if(a.length>0) {
            quickSort(a, 0 , a.length-1);
        }
    }

    private static void quickSort(int[] a, int left, int right) {
        //1,找到递归算法的出口，left=right交换base值，left<right交换标记值，left>right非法
        if( left> right) {
            return;
        }
        //2, 存储原始的left，right，用于后面的交换base值，分割区间等
        int i = left;
        int j = right;
        //3,选取Basae，以左侧第一个值当base
        int Base= a[ left];
        //4，完成一趟排序
        while( i< j) {
            //4.1 ，从右往左找到第一个小于key的数
            while(i<j && a[j] > Base){
                j--;
            }
            // 4.2 从左往右找到第一个大于key的数
            while( i<j && a[i] <= Base) {
                i++;
            }
            //4.3 交换，因为j--，i++后都不能保证i<j,所以在每一次i++，j--发生变动后，都要进行i<j的验证
            if(i<j) {
                int p = a[i];
                a[i] = a[j];
                a[j] = p;
            }
        }
        // 4.4，交换Base和哨兵碰面（i==j）的值
        int p = a[i];
        a[i] = a[left];//int Base = a[left]
        a[left] = p;

　　　　　　//左右不停分割
        //5, 对key左边的数快排
        quickSort(a, left, i-1 );//当i++，或j--，都会使i>j成立
        //6, 对key右边的数快排
        quickSort(a, i+1, right);
//注意，这里如果传入i++,i--,++i,--i,都会导致堆栈溢出
　因为：i--，i++会先完成方法内容，然后在做自减或自增
++i,--i理论上可以，但是因为这是依靠i，先进行左分割，然后依靠i进行右分割，i得保持不变，++i对i做了赋值，从而影响了右边分割

    }
}

快速排序的复杂度:

　　最糟糕的情况下, 复杂度为: O(n²)

　　最优的情况下, 复杂度为: O(nlog₂n)

最差情况下, 快速排序和冒泡排序的时间复杂度是O(n²),  但是最优情况下, 冒泡排序是 n * n, 而快速排序的是 n * log₂n,

如果n=16,

则冒泡是 16 * 16

快速排序是 16 * 4

可见, 只要你不是背到家, 都是比冒泡来的快的.

原文：https://blog.csdn.net/Yexiaofen/article/details/78018204?utm_source=copy