(1) Tipo de burbuja
① Principio:
En el intervalo desordenado, al comparar números adyacentes, burbujee el número más grande hasta el final del intervalo desordenado y continúe este proceso hasta que la matriz esté en orden como un todo.
②Implementación del código:
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;
}
}
}
}
Ejecutar captura de pantalla:
③Análisis de rendimiento
** Estabilidad: ** Estable
(2) Clasificación rápida
①Principio-partición:
1. Seleccione un número del intervalo que se ordenará como valor de referencia (pivote) ;
2. Partición: atraviese todo el intervalo para ordenar y coloque el valor más pequeño que el valor de referencia (que puede incluir igual) a la izquierda de el valor de referencia, que será mayor que el valor de referencia El mayor (que puede incluir valores iguales) se coloca en el lado derecho del valor de referencia;
3. Usando la idea de dividir y conquistar , las celdas izquierda y derecha se tratan en de la misma manera hasta la longitud entre celdas == 1, lo que significa que las celdas están en orden o las celdas están en orden. La longitud del intervalo == 0, lo que significa que no hay datos.
②Implementación del código:
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;
}
}
Ejecutar captura de pantalla:
Implementación del código después de la optimización (el tercer número es el método del medio):
/**
* @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;
}
}
La velocidad de clasificación de código optimizada se mejorará enormemente:
Después de ordenar una matriz con un tamaño de datos de 1_0000, el tiempo se ahorra aproximadamente 26 ms
③Análisis de rendimiento
Estabilidad: inestable