Intercambio se refiere a intercambiar las posiciones de los dos elementos en la secuencia de acuerdo con el resultado de la comparación de las palabras clave de los dos elementos en la secuencia. Entre muchos algoritmos de clasificación, el burbujeo y la clasificación rápida pertenecen a la clasificación de intercambio.
Uno, tipo burbuja
1. Idea básica:
Similar a burbujear en el agua, los más pequeños flotan y los más grandes se hunden. Compare dos números, el número más grande se mueve hacia atrás y el número más pequeño avanza.
2. Descripción del algoritmo:
Compare el último elemento de la secuencia con el elemento anterior en pares. Si está en el orden inverso, intercambie las posiciones de los elementos;
De acuerdo con el método anterior, realice una comparación por pares hasta el primer elemento, luego el primer elemento será el valor mínimo y la posición final;
Compare las secuencias restantes de acuerdo con los dos pasos anteriores hasta que se complete la clasificación.
3. Realización de la codificación:
def swap(s, a, b):
temp = s[a]
s[a] = s[b]
s[b] = temp
def bubblesort(instr):
n = len(instr)
for i in range(n-1):
for j in range(i,n)[::-1]:
if instr[j-1] > instr[j]:
swap(instr, j-1, j)
if __name__ == '__main__':
instr = input().split()
bubblesort(instr)
print(''.join(instr))El código anterior es el método de burbuja para lograr la clasificación. El número de comparaciones no tiene nada que ver con el estado inicial de la secuencia. Siempre es n * (n-1) / 2, por lo que la complejidad del tiempo es O (n ^ 2). Se utiliza un número constante de unidades auxiliares, por lo que la complejidad del espacio es O (1).
Pero si la secuencia inicial está en orden, esta comparación indudablemente desperdiciará recursos y tiempo. Para mejorar la eficiencia, se puede establecer un indicador de variable. Si el indicador es 0, significa que la secuencia es una secuencia ordenada y no hay necesidad de realizar una comparación de clasificación de burbujas, simplemente salga del ciclo directamente. De esta forma, en el mejor de los casos, el número de movimientos es 0, el número de comparaciones es n-1 y la complejidad de tiempo es O (n). La codificación es la siguiente:
def swap(s, a, b):
temp = s[a]
s[a] = s[b]
s[b] = temp
def bubblesort(instr):
n = len(instr)
for i in range(n-1):
flag = 0
for j in range(i,n)[::-1]:
if instr[j-1] > instr[j]:
swap(instr, j-1, j)
flag = 1
if flag == 0:
return
if __name__ == '__main__':
instr = input().split()
bubblesort(instr)
print(''.join(instr))4. Ejemplo:
Ordene la secuencia inicial: 5, 4, 3, 2, 1 de pequeño a grande
El primer proceso de clasificación: comparar 4 veces
、
、
、
、
El segundo proceso de clasificación: comparar 3 veces
、
、
、
El tercer proceso de clasificación: comparar 2 veces
、
、
El cuarto proceso de clasificación: compare 1 vez
、
5. Análisis de algoritmos:
Cada pasada de clasificación realiza comparaciones n-1. Después de cada pasada de comparación, un elemento se coloca en la posición final y el número de clasificaciones restantes es n-1. Se requiere un total de n-1 comparaciones. En el mejor de los casos, el número de comparaciones es n, el número de movimientos es 0 y la complejidad del tiempo es O (n); en el peor de los casos, el número de comparaciones es n * (n-1) / 2 y el número de movimientos es 3 * n * (n-1) / 2, la complejidad del tiempo es O (n ^ 2). Dado que no se realiza ninguna operación de intercambio cuando los elementos son iguales, la clasificación de burbujas es un algoritmo de clasificación estable.
Dos, clasificación rápida
1. Idea básica: según el método de divide y vencerás, la secuencia que se va a clasificar se divide en dos partes mediante una clasificación. Los elementos de una parte de la secuencia son más pequeños que el elemento de referencia y los elementos de la otra parte de la secuencia son más grandes que el elemento de referencia. Las dos partes de la secuencia se ordenan hasta que se ordena toda la secuencia.
2. Descripción del algoritmo:
Seleccione un elemento de referencia de la secuencia;
Ordene la secuencia, coloque todos los elementos más pequeños que el elemento de referencia en el frente, y coloque todos los elementos más grandes que el elemento de referencia en la parte posterior, y devuelva la posición final del elemento de referencia;
Divida la secuencia en dos subsecuencias según la posición del elemento de referencia;
Realice los tres pasos anteriores para cada parte de la secuencia hasta que la secuencia esté en orden.
3. Realización de la codificación:
def partition(instr, low, high):
p = instr[low]
while low < high:
while low < high and instr[high] >= p:
high = high-1
instr[low] = instr[high]
while low < high and instr[low] <= p:
low = low+1
instr[high] = instr[low]
instr[low] = p
return low
def quickSort(instr, low, high):
if low < high:
p = partition(instr,low,high)
quickSort(instr,low,p-1)
quickSort(instr,p+1,high)
if __name__ == '__main__':
instr = input().split()
quickSort(instr,0,len(instr)-1)
print(''.join(instr))4. Ejemplo:
Ordene la secuencia inicial: 3, 5, 1, 6, 2, 7, 4, 9 de pequeño a grande, tomando el primer elemento como punto de referencia
La primera partición: dividida en dos partes.
、
Divida en dos partes basándose en 3 y luego divida las dos secuencias antes y después de 3 como se indicó anteriormente hasta que las secuencias estén en orden.
5. Análisis de algoritmos:
Después de cada clasificación, el elemento de referencia se colocará en la posición final de la secuencia. En el mejor de los casos, la capacidad de espacio es consistente con la profundidad máxima de la llamada recursiva, que es log2 (n + 1). En el peor de los casos, se requieren n-1 llamadas recursivas y la profundidad de la pila es n-1. Por lo tanto, el máximo La complejidad del espacio es O (n) en el caso malo y O (log2 n) en el caso promedio. En el mejor de los casos, la complejidad temporal es O (n log2 n) y, en el peor de los casos, la complejidad temporal es O (n ^ 2). Si durante el proceso de clasificación, dos elementos son más pequeños que el elemento de referencia, ambos se moverán y el orden original puede cambiar, lo que puede provocar que el orden final sea inconsistente con el orden original. Por lo tanto, la clasificación rápida es un método de clasificación inestable.