Si hay 2 algoritmos que calculan el mismo resultado con diferentes complejidades, ¿O (log n) siempre será más rápido? Si es así, por favor explique. Por cierto, esta no es una pregunta de asignación.¿Es O (log n) siempre más rápido que O (n)
Respuesta
No. Si un algoritmo se ejecuta en N/100
y el otro en (log N)*100
, el segundo será más lento para tamaños de entrada más pequeños. Las complejidades asintóticas se refieren al comportamiento del tiempo de ejecución ya que los tamaños de entrada van al infinito.
entonces O (n) puede ser más rápido que O (log n) para una entrada extremadamente pequeña? – Varkolyn
1 * n es O (n). 10000000000000000000000000000000 * (log n) es O (log n). En tal caso, O (n) no solo será más rápido en una entrada extremadamente pequeña. Pero a medida que "n" crece hacia el infinito, * eventualmente * O (log n) será más rápido. –
@Varkolyn: No necesariamente * extremadamente *. Dependiendo del algoritmo, ¡el punto de cruce puede ser muy grande en * n *! – kkm
No, no siempre será más rápido. PERO, a medida que el tamaño del problema crece cada vez más, eventualmente siempre alcanzará un punto donde el algoritmo O (log n) es más rápido que el O (n).
En situaciones del mundo real, generalmente el punto donde el algoritmo O (log n) superaría al algoritmo O (n) vendría muy rápido. Hay una gran diferencia entre O (log n) y O (n), al igual que hay una gran diferencia entre O (n) y O (n^2).
Si alguna vez tiene la oportunidad de leer Perlas de programación por Jon Bentley, hay un capítulo increíble allí donde se enfrenta a un algoritmo O (n) contra un O (n^2) uno, haciendo todo lo posible da a O (n^2) la ventaja. (Codifica el algoritmo O (n^2) en C en un Alfa, y el algoritmo O (n) en BASIC interpretado en un viejo Z80 o algo así, corriendo a aproximadamente 1MHz.) Es sorprendente cuán rápido el O (n) el algoritmo supera al O (n^2) uno.
Ocasionalmente, sin embargo, puede encontrar un algoritmo muy complejo que tiene una complejidad ligeramente mejor que una más simple. En tal caso, no elija ciegamente el algoritmo con una gran O-mejor, puede encontrar que solo es más rápido en problemas extremadamente grandes.
- 1. ¿Qué es O (log * N)?
- 2. ¿Es log (n!) = Θ (n · log (n))?
- 3. Diferencia entre O (n) y O (log (n)) - ¿cuál es mejor y qué es exactamente O (log (n))?
- 4. ¿Qué significa O (log (log (n)))) - competitivo?
- 5. ¿Existe un término abreviado para O (n log n)?
- 6. ¿Por qué está ordenando una cadena O (n log n)?
- 7. ¿Qué compila para un código más rápido: "n * 3" o "n + (n * 2)"?
- 8. Big-O complejidad de c^n + n * (log n)^2 + (10 * n)^c
- 9. ¿Es posible calcular la mediana de una lista de números mejor que O (n log n)?
- 10. ¿Por qué se pasa del planificador O (1) al CFS que es O (log N)?
- 11. Cómo calcular n log n = c
- 12. Explicación intuitiva de por qué QuickSort es n log n?
- 13. ¿Cuál es la diferencia entre '\ n' o "\ n" en C++?
- 14. escribe o imprime, ¿qué es más rápido?
- 15. Algoritmo para encontrar el punto especial k en el tiempo O (n log n)
- 16. ¿doble o flotante, que es más rápido?
- 17. que es más rápido, equalsIgnoreCase o compareToIgnoreCase
- 18. que es más rápido? Declaración o PreparedStatement
- 19. ¿Podemos calcular esto en menos de O (n * n) ... (nlogn o n)
- 20. Ejemplo de O (n!)?
- 21. Obtener índice del elemento de matriz más rápido que O (n)
- 22. servidor SQL 'en' o 'o' - que es más rápido
- 23. ¿Se pueden ordenar n enteros en O (n) complejidad amortizada?
- 24. cuando es Java más rápido que C++ (o cuando JIT es más rápido que precompilado)?
- 25. lo hace O (N) significa
- 26. ¿Cuál es el significado de O (polylog (n))? En particular, ¿cómo se define polylog (n)?
- 27. Regex para despojar \ r \ n o \ r \ n
- 28. subcadena más larga que aparece n veces
- 29. ¿Qué ciclo es más rápido, mientras o para?
- 30. Cualquier idea de cómo transformar este O (n^2) algo en un O (n)
Siempre será más rápido para lo suficientemente grande * n *. – Phonon