一.冒泡排序：
外层循环控制排序躺数：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(n2)
最优的情况下, 复杂度为: O(nlog2n)
最差情况下, 快速排序和冒泡排序的时间复杂度是O(n2), 但是最优情况下, 冒泡排序是 n * n, 而快速排序的是 n * log2n,
如果n=16,
则冒泡是 16 * 16
快速排序是 16 * 4
可见, 只要你不是背到家, 都是比冒泡来的快的.
原文：https://blog.csdn.net/Yexiaofen/article/details/78018204?utm_source=copy