（1）冒泡排序
①原理：
在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序
②代码实现：
import java.util.Arrays;
//冒泡排序： 时间复杂度O(n^2) 空间复杂度：O(1)
public class bubbleSort {
public static void main(String[] args) {
int[] array={
5,8,1,2,5,22,44,15,3,0,48};
System.out.println(Arrays.toString(array));
bubble(array);
System.out.println(Arrays.toString(array));
}
public static void bubble(int[] array){
for (int i = 0; i < array.length - 1; i++) {
boolean isSorted = true;
for (int j = 0; j < array.length - i - 1; j++) {
// 相等不交换，保证稳定性
if (array[j] > array[j + 1]) {
int tmp=array[j];
array[j]=array[j+1];
array[j+1]=tmp;
isSorted = false;
}
}
if (isSorted) {
break;
}
}
}
}
运行截图：
③性能分析
**稳定性：**稳定
（2）快速排序
①原理–partition：
1.从待排序区间选择一个数，作为基准值(pivot)；
2.Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边；
3.采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间的长度 == 0，代表没有数据。
②代码实现：
import java.util.Arrays;
/**
* 快速排序 时间复杂度：O(n*log2n)~O(n^2) 空间复杂度：O(log2n)~O(n)
*稳定性：不稳定
*/
public class quickSort {
public static void main(String[] args) {
int[] array={
4,8,7,5,12,14,0,3,36,24};
System.out.println(Arrays.toString(array));
quickSort1(array);
System.out.println(Arrays.toString(array));
}
//快速排序函数
public static void quickSort1(int[] array){
quick(array,0,array.length-1); //接口
}
public static void quick(int[] array,int low,int high){
if(low<high){
int piv=pivot(array,low,high);
quick(array,low,piv-1); //递归实现
quick(array,piv+1,high);
}
}
//找基准的函数
public static int pivot(int[] array,int start,int end){
int tmp=array[start];
while(start<end){
while(start<end && array[end]>=tmp){
end--;
}
//把数值赋值给start
array[start]=array[end];
while(start<end && array[start]<=tmp){
start++;
}
//把start下标的值给end
if(start>=end){
break;
}else{
array[end]=array[start];
}
}
array[start]=tmp;
return start;
}
}
运行截图：
优化后代码实现（三数取中法）：
/**
* @Author: XiShanShan
* @Description:
* @Date:Created in 20:21 2021/3/30
* @Modified By:xss666
*/
import java.util.Arrays;
/**
* 快速排序 时间复杂度：O(n*log2n)~O(n^2) 空间复杂度：O(log2n)~O(n)
*稳定性：不稳定
*/
public class quickSort {
public static void main(String[] args) {
int[] array=new int[1_0000];
for (int i = 0; i < array.length; i++) {
array[i]=i;
}
quickSort1(array);
}
//快速排序函数
public static void quickSort1(int[] array){
long startTime=System.currentTimeMillis();
quick(array,0,array.length-1); //接口
long endTime=System.currentTimeMillis();
System.out.println(endTime-startTime); //输出排序所需要的时间
}
public static void swap(int[] array,int k,int i){
int tmp=array[k];
array[k]=array[i];
array[i]=tmp;
}
//三数取中法优化
public static void medianOfThree(int[] array,int low,int high){
int mid=(low+high)/2;
if(array[low]<=array[mid]){
swap(array,low,mid);
}//mid<=low
if(array[low]>array[high]){
swap(array,low,high);
}//array[low]<=array[high]
if(array[mid]>array[high]){
swap(array,mid,high);
} //array[mid]<array[high]
}
public static void quick(int[] array,int low,int high){
if(low<high){
//优化后
medianOfThree(array,low,high);
int piv=pivot(array,low,high);
quick(array,low,piv-1); //递归实现
quick(array,piv+1,high);
}
}
//找基准的函数
public static int pivot(int[] array,int start,int end){
int tmp=array[start];
while(start<end){
while(start<end && array[end]>=tmp){
end--;
}
//把数值赋值给start
array[start]=array[end];
while(start<end && array[start]<=tmp){
start++;
}
//把start下标的值给end
if(start>=end){
break;
}else{
array[end]=array[start];
}
}
array[start]=tmp;
return start;
}
}
优化后的代码排序的速度会大大提高：
将1_0000个数据大小的数组排序后，时间节省了26ms左右
③性能分析
稳定性： 不稳定