冒泡排序+快速排序

一.冒泡排序：

外层循环控制排序躺数：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+" ");
 　　　　} 
　　}
 }

二.快速排序：

  快速排序，顾名思义，是一种速度快，效率高的排序算法。
快排原理：
      在要排的数（比如数组A）中选择一个中心值key（比如A[0]），通过一趟排序将数组A分成两部分，其中以key为中心，key右边都比key大，key左边的都key小，然后对这两部分分别重复这个过程，直到整个有序。
    整个快排的过程就简化为了一趟排序的过程，然后递归调用就行了。
      一趟排序的方法：
1，定义i=0，j=A.lenght-1，i为第一个数的下标，j为最后一个数下标
2，从数组的最后一个数Aj从右往左找，找到第一小于key的数，记为Aj；
3，从数组的第一个数Ai 从左往右找，找到第一个大于key的数，记为Ai；
4，交换Ai 和Aj
5，重复这个过程，直到 i=j
6，调整key的位置，把A[i] 和key交换
假设要排的数组为：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 low, int high) {
        //1,找到递归算法的出口
        if( low > high) {
            return;
        }
        //2, 存
        int i = low;
        int j = high;
        //3,key
        int key = a[ low ];
        //4，完成一趟排序
        while( i< j) {
            //4.1 ，从右往左找到第一个小于key的数
            while(i<j && a[j] > key){
                j--;
            }
            // 4.2 从左往右找到第一个大于key的数
            while( i<j && a[i] <= key) {
                i++;
            }
            //4.3 交换
            if(i<j) {
                int p = a[i];
                a[i] = a[j];
                a[j] = p;
            }
        }
        // 4.4，调交换key和零界点的值
        int p = a[i];
        a[i] = a[low];
        a[low] = p;
        //5, 对key左边的数快排
        quickSort(a, low, i-1 );
        //6, 对key右边的数快排
        quickSort(a, i+1, high);
    }
}

快速排序的复杂度:

　　最糟糕的情况下, 复杂度为: 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

冒泡排序+快速排序

猜你喜欢