Intercambiar clasificación: compare los códigos de clave de dos registros en la tabla de clasificación, si es contrario al requisito de clasificación, intercambie los dos.
1. Clasificación de burbujas
1. Idea básica: Para tratar la secuencia de clasificación de adelante hacia atrás, compare los códigos de clasificación de los elementos adyacentes por turnos e intercambie si se encuentra el orden inverso, de modo que los elementos con códigos de clasificación más grandes se muevan gradualmente desde el frente hacia la parte posterior.
2. Resultado del código:
排序之前：
[9, -16, 21, 23, -30, -49, 21, 30, 30]
开始排序
[-16, 9, 21, -30, -49, 21, 23, 30, 30]
[-16, 9, -30, -49, 21, 21, 23, 30, 30]
[-16, -30, -49, 9, 21, 21, 23, 30, 30]
[-30, -49, -16, 9, 21, 21, 23, 30, 30]
[-49, -30, -16, 9, 21, 21, 23, 30, 30]
[-49, -30, -16, 9, 21, 21, 23, 30, 30]
排序之后：
[-49, -30, -16, 9, 21, 21, 23, 30, 30]3. Gráfico:
4. Análisis de eficiencia:
Como se puede ver en el algoritmo de burbujeo original,
Cuando los elementos a ordenar están en orden positivo, solo se realiza un ciclo, se comparan n-1 tiempos y el número de elementos en movimiento es 0;
Cuando los elementos que se van a ordenar están en orden inverso, es necesario realizar n-1 ciclos, comparar (n ^ 2-n) / 2 veces y mover los elementos 3 * (n ^ 2-n) / 2 veces;
Por lo tanto, la complejidad del tiempo es O (n ^ 2); debido a que hay demasiados elementos en movimiento, es el más lento en la clasificación interna; debido a que la clasificación de burbujas solo se mueve secuencialmente entre elementos, es un algoritmo estable.
5. Código de prueba:
Codigo original:
public class BubbleSort {
public static void bubbleSort(int[] data) {
System.out.println("开始排序");
int arrayLength = data.length;
for (int i = 0; i < arrayLength - 1; i++) {
for (int j = 0; j < arrayLength - 1 - i; j++) {
if (data[j] > data[j + 1]) {
int temp = data[j + 1];
data[j + 1] = data[j];
data[j] = temp;
}
}
System.out.println(java.util.Arrays.toString(data));
}
}
public static void main(String[] args) {
int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };
System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
bubbleSort1(data);
System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
}
}Optimización 1: Incrementar la nota Si no hay intercambio entre j = 0 e i, la nota es verdadera, indicando que la secuencia de intervalo ya está ordenada, reduciendo comparaciones innecesarias y mejorando la eficiencia.
//优化1
public static void bubbleSort1(int[] data) {
System.out.println("开始排序");
int arrayLength = data.length;
for (int i = 0; i < arrayLength - 1; i++) {
boolean flag = false;
for (int j = 0; j < arrayLength - 1 - i; j++) {
if (data[j] > data[j + 1]) {
int temp = data[j + 1];
data[j + 1] = data[j];
data[j] = temp;
flag = true;
}
}
System.out.println(java.util.Arrays.toString(data));
if (!flag)
break;
}
}
Optimización 2: Registre la posición del último número de cada intercambio de ciclo, registre la posición y recupere la posición la próxima vez (porque la secuencia desde la posición hasta la última posición ya está en orden).
//优化2
public static void bubbleSort2(int[] data) {
System.out.println("开始排序");
int arrayLength = data.length;
int i=arrayLength-1;
int pos=0;
while(i>0) {
for (int j = 0; j <i; j++) {
if (data[j] > data[j + 1]) {
pos=j;
int temp = data[j + 1];
data[j + 1] = data[j];
data[j] = temp;
}
}
System.out.println(java.util.Arrays.toString(data));
i=pos;
}
}Hay otros métodos de optimización, aquí están solo los que son más fáciles de entender y escribir.
2. Clasificación rápida (énfasis) (clasificación de intercambio de particiones)
Es el más rápido entre todos los algoritmos de filas internas hasta ahora.
1. Idea básica: tome cualquier elemento de la secuencia que desee clasificar como estándar (también llamado punto de pivote, punto límite, generalmente el primer elemento) y divida el elemento que desee clasificar en dos subsecuencias, izquierda y derecha. El código de clasificación de los elementos de la subsecuencia es menor que el código de clasificación del elemento de referencia, y el código de clasificación de la subsecuencia derecha es mayor o igual que el código de clasificación del elemento de referencia, y luego las dos subsecuencias se dividen por separado hasta que solo hay un elemento en cada secuencia. La secuencia obtenida es una secuencia ordenada.
2. Icono:
3. Un proceso de división:
1.low指向待划分区域首元素,high指向待划分区域尾元素:
2.R[0]=R[low] (为了减少数据的移动将作为标准的元素暂存
到R[0]中,最后再放入最终位置)
3.high从后往前移动直到R[high].key<R[0]key;
4. R[low]=R[high], low++
5.low从前往后移动直到R[low].key>=R[0].key;
6. R[high]=R[low], high--
7. goto 3
8.直到 loW==hgh 时,R[low]=R[0](即将作为标准的元素放到
其最终位置)
概括地说,一次划分就是从表的两端交替地向中间进行扫描
将小的放到左边,大的放到右边,作为标准的元素放到中间。4. Análisis de eficiencia:
5. Código de prueba:
public class QuickSort0 {
private static void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
private static void subSort(int[] data, int start, int end) {
if (start < end) {
int base = data[start];
int low = start;
int high = end + 1;
while (true) {
while (low < end && data[++low] - base <= 0)
;
while (high > start && data[--high] - base >= 0)
;
if (low < high) {
swap(data, low, high);
} else {
break;
}
}
swap(data, start, high);
subSort(data, start, high - 1);//递归调用
subSort(data, high + 1, end);
}
System.out.println(java.util.Arrays.toString(data));
}
public static void quickSort(int[] data){
subSort(data,0,data.length-1);
}
public static void main(String[] args) {
int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
System.out.println("开始排序");
quickSort(data);
System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
}
}