一.冒泡排序：
外层循环控制排序躺数：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
来源：https://www.cnblogs.com/brxHqs/p/9792419.html