Cómo analizar la complejidad del tiempo de ejecución del algoritmo de búsqueda binaria recursiva

Aquí hay código recursivo para búsqueda binaria.

BinarySearch (A, inicio, fin, objetivo)
si inicio> fin entonces
volver NO ENCONTRADO
mid = floor ((inicio + final) / 2)
si A [medio] = objetivo entonces
volver a mediados
de lo contrario si el objetivo <A [medio] entonces // mira a la izquierda
return BinarySearch (A, inicio, mediados de 1, objetivo)
más // mira bien
return BinarySearch (A, mid + 1, end, target)

Podemos escribir una recurrencia para este algoritmo:

Deje que [math] T (n) [/ math] represente el tiempo de ejecución de la búsqueda binaria. Entonces podemos escribir [matemáticas] T (n) = T (\ frac {n} {2}) + \ Theta (1) [/ matemáticas]

Donde [matemáticas] n = final-inicio + 1. [/matemáticas]

Hay algo llamado el teorema maestro que dice: (más o menos)

Si tiene una recurrencia que se parece a

[matemáticas] T (n) = a T (\ frac {n} {b}) + f (n) [/ matemáticas]

Entonces lo que haces es comparar [matemáticas] f (n) [/ matemáticas] y [matemáticas] n ^ {log_b (a)}. [/ Matemáticas]

Si [math] f (n) [/ math] es polinomialmente más grande que [math] n ^ {log_b (a)} [/ math], entonces el tiempo de ejecución es [math] \ Theta (f (n)) [/ math ]

Si es lo contrario, entonces el tiempo de ejecución es [math] \ Theta (n ^ {log_b (a)}) [/ math].

Si las funciones son iguales (en notación [matemática] \ Theta [/ matemática]), el tiempo de ejecución es [matemática] \ Theta (f (n) \ log n). [/matemáticas]

En la búsqueda binaria [matemática] f (n) = 1 [/ matemática], [matemática] a = 1 [/ matemática] y [matemática] b = 2 [/ matemática]. [matemática] \ log_b (a) = \ log_2 1 = 0. [/ matemática] Entonces [matemática] n ^ 0 = f (n). [/matemáticas]

Entonces el tiempo de ejecución es [matemática] \ Theta (\ log n). [/matemáticas]

Vea la respuesta de Daniel R. Page a ¿Cuál es la complejidad temporal del algoritmo de búsqueda binaria?

La relación de recurrencia para el tiempo de ejecución del método es:

T (1) = a si n = 1 (matriz de un elemento)

T (n) = T (n / 2) + b si n> 1

Sin pérdida de generalidad, suponga que n, el tamaño del problema, es un múltiplo de 2, es decir, n = 2k

En expansión:

T (1) = a (1)

T (n) = T (n / 2) + b (2)

= [T (n / 22) + b] + b = T (n / 22) + 2b sustituyendo T (n / 2) en (2)

= [T (n / 23) + b] + 2b = T (n / 23) + 3b sustituyendo T (n / 22) en (2)

= …… ..

En i-ésima recursión

T (i) = T (n / 2i) + ib

= T (n / 2k) + kb

Cuando n = 2k

T (n) = T (2k / 2k) + log2 n. si

T (n) = T (1) + b. log2 n

El caso base se alcanza cuando n / 2k = 1 è n = 2k è k = log2 n, entonces tenemos:

= a + b log2 n

Por lo tanto, la búsqueda binaria recursiva es O (log n)

Es lo mismo que la complejidad temporal de un algoritmo iterativo de búsqueda binaria, suponiendo que el compilador maneja correctamente la recursividad de cola. (Si observa el código de Ari Mermelstein, verá que es recursivo).

Como otros han señalado, el tiempo máximo de ejecución es [matemática] O (\ log_2 N) [/ matemática] y el tiempo mínimo de ejecución es [matemática] O (1) [/ matemática] ya que es posible obtener la respuesta en El primer intento.