Clasificación de intercambio básico de Java (clasificación de burbujas, clasificación rápida)

1. Clasificación de burbujas

  • Principio: En un 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é ordenada como un todo.

  • Estabilidad (estable)
    1. Una secuencia estable puede convertirse en una secuencia inestable,
    2. Una secuencia estable no puede volverse estable;

  • Complejidad espacial: O (1)

  • Complejidad temporal: mejor caso O (n); peor caso O (n ^ 2)

//冒泡排序
    public static void bubbleSort(int[] arr){
    
    
        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 tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
    }

2. Clasificación rápida

  • Principio:
    1. Seleccione un número del intervalo que se ordenará como pivote;
    2. Partición: atraviese todo el intervalo para ordenar y coloque un valor menor que el punto de referencia (que puede contener igual) a la izquierda del valor de referencia. , y comparar El valor de referencia más grande (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 de la izquierda y la derecha se tratan de la misma manera hasta que la longitud entre el celdas == 1, lo que significa que está en orden. O la longitud entre celdas == 0, lo que significa que no hay datos.
  • Estabilidad (inestable)

1. Un tipo estable puede convertirse en un tipo inestable;

2. Uno inherentemente inestable no puede volverse estable;

  • Complejidad del espacio: O (log2n)
  • Complejidad de tiempo: Grado: O (n * logn)
//快速排序
public static void quicksort(int[] arr){
    
    
        quick(arr,0,arr.length-1);

    }
    //排序
    public static void quick(int[] arr,int low,int high){
    
    
        if(low > high){
    
    
            return;
        }
        //par是基准
        int par = parttion(arr,low,high);
        quick(arr,low,par-1);
        quick(arr,par+1,high);
    }
    //划分函数
    public static int parttion(int[] arr,int start,int end){
    
    
        //申请一个tmp空间用来放基准的值(基准一般选择的是边上的值)
        int tmp = arr[start];//这里取的是最左边的值,那么一会就先从最右边开始找[end]位置
        while(start < end){
    
    
            while(start < end && arr[end] >= tmp){
    
    
                end--;
            }
            //到了这里,从while出来有俩种情况,不满足start < end或者不满足arr[end] >= tmp
            if (start >= end){
    
    
                //arr[start] = tmp;
                break;//直接退出,因为已经遍历完毕
            }else{
    
    //else就是arr[end] < tmp
                arr[start] = arr[end];
            }
            while(start < end && arr[start] <= tmp){
    
    
                start++;
            }
            //到了这里,同样从while出来有俩种情况,不满足start < end或者不满足arr[start] <= tmp
            if (start > end){
    
    
                //arr[end] = tmp;
                break;
            }else{
    
    
                arr[end] = arr[start];
            }
        }
        arr[start] = tmp;
        return start;//返回基准移动到位置,这样基准的左边全小于它,右边全都大于它

3. Prueba de resultado

public class TestSort {
    
    
//冒泡排序
    public static void bubbleSort(int[] arr){
    
    
        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 tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
    }
//快速排序
public static void quicksort(int[] arr){
    
    
        quick(arr,0,arr.length-1);

    }
    //排序
    public static void quick(int[] arr,int low,int high){
    
    
        if(low > high){
    
    
            return;
        }
        //par是基准
        int par = parttion(arr,low,high);
        quick(arr,low,par-1);
        quick(arr,par+1,high);
    }
    //划分函数
    public static int parttion(int[] arr,int start,int end){
    
    
        //申请一个tmp空间用来放基准的值(基准一般选择的是边上的值)
        int tmp = arr[start];//这里取的是最左边的值,那么一会就先从最右边开始找[end]位置
        while(start < end){
    
    
            while(start < end && arr[end] >= tmp){
    
    
                end--;
            }
            //到了这里,从while出来有俩种情况,不满足start < end或者不满足arr[end] >= tmp
            if (start >= end){
    
    
                //arr[start] = tmp;
                break;//直接退出,因为已经遍历完毕
            }else{
    
    //else就是arr[end] < tmp
                arr[start] = arr[end];
            }
            while(start < end && arr[start] <= tmp){
    
    
                start++;
            }
            //到了这里,同样从while出来有俩种情况,不满足start < end或者不满足arr[start] <= tmp
            if (start > end){
    
    
                //arr[end] = tmp;
                break;
            }else{
    
    
                arr[end] = arr[start];
            }
        }
        arr[start] = tmp;
        return start;//返回基准移动到位置,这样基准的左边全小于它,右边全都大于它
}


//测试main方法
public static void main(String[] args) {
    
    
//冒泡排序
        int[] arr3 = {
    
    7,4,9,34,0,8,5,22,55,6,12,33,56,89,77};
        bubbleSort(arr3);
        System.out.print("冒泡排序结果: ");
        for (int i = 0;i < arr3.length;i++){
    
    
            System.out.print(arr3[i]+" ");
        }
        //快速排序
        int[] arr5 = {
    
    7,4,9,34,0,8,5,22,55,6,12,33,56,89,77};
        quicksort(arr5);
        System.out.print("快速排序结果: ");
        for (int i = 0;i < arr5.length;i++){
    
    
            System.out.print(arr5[i]+" ");
        }
}

Inserte la descripción de la imagen aquí

Supongo que te gusta

Origin blog.csdn.net/qq_45665172/article/details/109648630
Recomendado
Clasificación