¿Puede mostrar que la ordenación por fusión tiene complejidad de tiempo [matemática] O (n \ log n) [/ matemática]?

Dividir paso

Deje que haya una matriz de n elementos … fusionar ordenación, al ser una relación de recurrencia de tipo dividir y conquistar, tiende a tomar la matriz y dividirla en 2 subarreglos de igual tamaño (es decir, subarreglos que contienen n / 2 elementos para una matriz de n elementos ) de forma recursiva hasta que las sub matrices contengan solo 1 elemento.

Por lo tanto, este procedimiento de división lleva un tiempo D (n) = 2D (n / 2) : n se divide en 2 subconjuntos de n / 2 elementos.

Conquistar paso

En la etapa de conquista, los primeros elementos de cada subconjunto se comparan entre sí y el elemento más pequeño se coloca como el primer elemento del conjunto principal. Luego, el segundo segundo elemento de una matriz se convierte en su elemento primario y se compara con el primer elemento de la segunda matriz. Este proceso toma comparaciones n-1 en total, ya que no es necesario comparar el último elemento.

Este procedimiento de conquista, por lo tanto, toma C (n) = n-1

Divide y conquistaras

En total divide y vencerás, por lo tanto, toma T (n) = D (n) + C (n) => T (n) = 2T (n / 2) + n-1 => T (n) = 2T (n / 2) + O (n)

Solución de Akra-Bazzi a la relación de recurrencia:

T (n) = 2T (n / 2) + n es una relación de divide y vencerás

donde a = 2 ; b = 1/2 ;

Por lo tanto,

Paso 1: establecemos p tal que a * (b) ^ p = 1 => 2 * (1/2) ^ 1 = 1

Paso 2: Conecte p = 1 yg (u) = g (n) = n en: T (n) = θ (n + n ∫ (n / n * n) du)
=> T (n) = θ (n + n∫ (1 / n) du) => T (n) = θ (n + n (lg n))

=> T (n) = θ (n lg n)

QED

El diagrama que se muestra es útil, en cada nivel habrá una cierta cantidad de elementos fusionados, ¿cuántos?

Donde c es una constante:

Nivel 1: cn

Nivel 2: 2 grupos de tamaño 1 / 2n, o 2 * cn / 2 = cn

Nivel 3: 4 grupos de tamaño 1 / 4n, o 4 * cn / 4 = cn

Nivel 4: 8 grupos de tamaño 1 / 8n, u 8 * cn / 8 = cn

…

Nivel final: n grupos de tamaño 1, o n * cn / n = cn

Una lista de tamaño n solo puede subdividirse en niveles de obstrucción,

entonces la complejidad del tiempo es c (n * logn) u O (nlogn)

Combinar ordenar combina listas después de dividirse en varias listas exponencialmente (potencia de 2). Por ejemplo –

No. de listas hechas por iteración – 1 -> 2 -> 4 ->… .. -> n

“N” es el número de elementos y, por lo tanto, en la última iteración hay “n” listas de 1 elemento en cada lista. Ahora, suponga que la fusión toma 1 unidad de tiempo, ya que la fusión es una operación de comparación simple.

Como las listas son exponenciales, llevaría tiempo log n llegar a una lista en la enésima posición.

Como hay n listas … el recorrido general toma nx log ny la comparación toma 1 unidad. Por lo tanto, la complejidad general del tiempo es nx log nx 1 = O (nlogn).

Esta es la explicación más simple (versión novata, sin matemática detallada).

Para simplificar el análisis, la clasificación de elementos [matemáticos] n [/ matemáticos] se realiza más rápido que la clasificación de elementos [matemáticos] 2 ^ k [/ matemáticos], donde [matemática] k [/ matemática] es la opción más pequeña posible donde [matemáticas] 2 ^ k \ geq n [/ matemáticas]. Esto significa que solo tenemos que analizar el comportamiento asintótico para listas con una potencia de longitud de dos.

Merge Sort ordena las listas de longitud 2 (pasando por todos los elementos una vez), luego se fusiona para obtener listas de longitud 4 (pasando nuevamente por todos los elementos exactamente una vez para este nivel), luego otro nivel para las listas de longitud 8, y así sucesivamente , hasta que tengamos el pase final, [math] k [/ math] -th, para la lista única de longitud [math] 2 ^ k [/ math].

Esto es más fácil de probar para la combinación de abajo hacia arriba, donde comienza con las listas [math] n [/ math] de longitud 1, que luego combina repetidamente en pares, para obtener las primeras listas [math] n / 2 [/ math] de longitud 2, luego [matemáticas] n / 4 [/ matemáticas] listas de longitud 4, y así sucesivamente.

Luego, primero prueba que cada pasada sobre los datos se ejecuta en [math] O (n) [/ math], y luego que [math] O (\ log n) [/ math] pasa sobre la matriz suficiente para hacer que todo funcione ordenado

Si seguro. Conferencia completa sobre MergeSort: