1. Clasificación de burbujas
Ordenamiento de burbuja
Es un algoritmo de clasificación basado en operaciones de comparación e intercambio . El proceso de cada ronda de burbujeo comienza desde el primer elemento, compara e intercambia este elemento con el siguiente elemento adyacente , de modo que el elemento más grande se mueva hacia la derecha (si el elemento es más grande que el siguiente elemento, entonces los dos elementos se intercambian; si el elemento es menor o igual que el siguiente elemento, déjelo sin cambios). De esta manera, cada ronda del proceso de burbujeo puede determinar que un elemento se coloca en la posición correcta, y este elemento es el elemento más grande entre los elementos restantes, y la posición correcta es la posición más a la derecha entre las posiciones restantes. Este proceso es como burbujas flotando, por eso se llama clasificación de burbujas.
1. Ilustración
2. Código
package com.kfm.it.Rank;
public class BubleSort {
public static void main(String[] args) {
//1.先初始化数组
int[] a = {45, 5, 4, 67, 54};
//外层循环，它决定一共走几趟
for (int i = 0; i < a.length - 1; i++) {
//2.交换位置//内层循环，它决定每趟走一次
for (int j = 0; j < a.length - 1; j++) {
if (a[j] > a[j + 1]) {
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
printArr(a);
}
private static void printArr(int[] a) {
for (int j = 0; j < a.length; j++) {
System.out.print(a[j] + " ");
}
System.out.println();
}
}3. Complejidad
Complejidad temporal: Peor caso: O(N^2)
Mejor caso: O(N)
Complejidad espacial: O(1)
2. Seleccione clasificación
Idea básica: busque el elemento más pequeño (grande) en la secuencia sin clasificar, guárdelo al principio de la secuencia ordenada, luego continúe buscando el elemento más pequeño (grande) de los elementos restantes sin clasificar y luego colóquelo al final de la secuencia. secuencia ordenada. Y así sucesivamente hasta que todos los elementos estén ordenados.
-
Pasos de implementación para la clasificación por selección:
- Comenzando desde el primer elemento, compárelo con el primer elemento de la parte sin clasificar, si el elemento es más pequeño, intercambie la posición de este elemento con el primer elemento de la parte sin clasificar;
- Si el elemento es más grande, la búsqueda continúa hacia atrás hasta que se encuentra un elemento más pequeño o se llega al final de la sección sin clasificar.
- Intercambie el elemento más pequeño encontrado con el primer elemento de la parte sin clasificar.
- Repita los pasos anteriores hasta que todos los elementos estén ordenados.
1. Ilustración
2. Código
package com.kfm.it.Rank;
public class SelectSort {
public static void main(String[] args) {
int[] a = {43,56,45,6,457,65,67};
for (int i = 0; i < a.length - 1; i++) {
//从第二个数开始
for (int j = i+1; j < a.length; j++) {
if (a[i] > a[j]) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
printArr(a);
}
private static void printArr(int[] a) {
for (int j = 0; j < a.length; j++) {
System.out.print(a[j] + " ");
}
System.out.println();
}
}
3. Complejidad
La complejidad temporal de la clasificación por selección: O (n ^ 2), donde n es el número de elementos que se ordenarán. Porque cada vez es necesario recorrer todos los elementos en la parte sin clasificar para encontrar el elemento más pequeño (grande).
Complejidad espacial de la clasificación por selección: O (1), solo se necesita espacio adicional de nivel constante para almacenar variables temporales
3. Ordenación por inserción
La ordenación por inserción y la ordenación por selección tienen el mismo efecto porque ambos tienen la idea de crear una submatriz en la matriz original . Ambos métodos de clasificación dividirán la matriz original en dos partes: la matriz que se va a ordenar y la matriz ordenada. .
1. Ilustración
2. Código
package com.kfm.it.Rank;
import java.util.Arrays;
public class chaSort {
public static void main(String[] args) {
int[] arr = {34, 3, 54, 5, 56, 5, 76, 45, 4, 5};
for (int i = 1; i < arr.length; i++) {
for (int j = i - 1;j >= 0;j--) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
printArr(arr);
}
private static void printArr(int[] arr) {
for (int j = 0; j < arr.length; j++) {
System.out.print(arr[j] + " ");
}
System.out.println();
}
}
3. Complejidad
Complejidad del tiempo: O (N * N) en el peor de los casos. En este momento, las columnas a ordenar están en orden inverso o cerca del orden inverso. En el mejor de los casos, es O (N). En este momento
, las columnas a ordenar están en orden ascendente o cerca del orden ascendente.
Complejidad espacial: O (1)