Análisis de Algoritmos

BEng & M.Sc. Sebastian David Ariza Coll

Introducción a los algoritmos y complejidad

Un algoritmo es un conjunto de pasos o reglas para resolver un problema o realizar una tarea. En informática, se usa para diseñar programas y puede representarse con pseudocódigo, diagramas de flujo o código. Los algoritmos se aplican tanto a problemas simples como complejos, y su calidad depende de que sean correctos, eficientes, escalables y fáciles de mantener.

Un ejemplo sencillo de algoritmo es ordenar tres números de menor a mayor:

Problema: Ordenar los números 8, 3 y 5.

Algoritmo (pasos):

Comparar el primer número con el segundo.
Si el primero es mayor, intercambiarlos.
Comparar el segundo número con el tercero.
Si el segundo es mayor, intercambiarlos.
Volver a comparar el primero con el segundo para asegurar el orden.

Resultado: 3, 5, 8.

¿Complejidad?

La complejidad de un algoritmo mide qué tan eficiente es, es decir, cómo cambian el tiempo de ejecución o el uso de memoria cuando aumenta el tamaño de los datos de entrada.

Hay dos tipos principales:

Complejidad temporal (Time Complexity): mide cuánto tiempo tarda el algoritmo en ejecutarse según el tamaño de la entrada, usando notación Big-O como O(1), O(n) o O(n²).
Complejidad espacial (Space Complexity): mide cuánta memoria utiliza el algoritmo dependiendo del tamaño de la entrada.

Analizar la complejidad ayuda a elegir el algoritmo más adecuado según los datos, los recursos disponibles y la velocidad deseada.

4) Espacio de complejidad

Cantidad de memoria o espacio que utiliza un algoritmo en función del tamaño de la entrada.

3) Tiempo de Complejidad

Cantidad de tiempo que tarda un algoritmo en ejecutarse en función del tamaño de la entrada.

2) Complejidad

Medida de la eficiencia de un algoritmo.

1) Algoritmos

Procedimiento paso a paso o conjunto de reglas para resolver un problema específico o realizar una tarea particular.

Algoritmos y Complejidad

Consumo de energía

Algoritmos muy complejos pueden gastar mucha energía, lo cual es un problema en dispositivos con batería o sistemas eficientes.

Diferencia de Hardware

Un algoritmo puede funcionar bien en una máquina pero no estar optimizado para otra.

Limitación de recursos

Las máquinas tienen CPU, memoria y almacenamiento limitados, lo que puede causar lentitud o fallos.

Escalabilidad

La complejidad del algoritmo determina cómo funciona cuando crecen los datos; algunos se vuelven muy lentos con entradas grandes.

¿Por qué no podemos depender de la máquina?

Aspectos básicos de python

Python es un lenguaje de programación de propósito general que se usa en áreas como desarrollo web, ciencia de datos y aprendizaje automático.
Es fácil de aprender y tiene una gran comunidad de desarrolladores.
La presentación cubre conceptos básicos como:
- listas
- tuplas, sets
- diccionarios
- cadenas de texto
- números.

Introducción al análisis de algoritmos

Eficiencia y eficacia.

En el análisis de algoritmos, la eficiencia significa usar bien los recursos (tiempo y memoria), mientras que la eficacia significa resolver correctamente el problema. Al diseñar algoritmos, es importante equilibrar ambas para obtener resultados correctos sin gastar recursos innecesarios.

Introducción al análisis de algoritmos

Eficiencia:

En el análisis de algoritmos, la eficiencia es la capacidad de un algoritmo para usar de forma óptima recursos como el tiempo y la memoria cuando aumenta el tamaño del problema.
Para medirla se utiliza la notación asintótica, como la notación Big O, que describe cómo crecen el tiempo de ejecución y el uso de memoria.
El objetivo es crear algoritmos que resuelvan problemas rápidamente y con el menor consumo de recursos posible.

Introducción al análisis de algoritmos

Eficacia:

la eficacia es la capacidad de un algoritmo para resolver correctamente el problema en todas las situaciones posibles.
Se verifica mediante pruebas para asegurar que produce resultados correctos y confiables.
La eficacia se centra en que el algoritmo dé la solución correcta, mientras que la eficiencia se enfoca en el uso de recursos como tiempo y memoria.
Ambos aspectos son importantes y deben equilibrarse para obtener soluciones rápidas y precisas.

Ecuación del tiempo

La ecuación de tiempo de un algoritmo es una función matemática que muestra cómo cambia el tiempo de ejecución según el tamaño de los datos de entrada.
Permite estimar cuánto tardará un algoritmo en resolver un problema y cómo su rendimiento escala cuando el problema crece.
Es útil para analizar la eficiencia y elegir el algoritmo más adecuado según los recursos disponibles.

T(n) : \mathbb{N} \rightarrow \mathbb{R}^+

Ecuación del tiempo

La ecuación de tiempo de un algoritmo

T(n) = f(n) : \mathbb{N} \rightarrow \mathbb{R}^+

Donde:

T(n) representa el tiempo de ejecución del algoritmo para una entrada de tamaño n.
f(n) es una función que describe cómo crece el tiempo de ejecución a medida que el tamaño de entrada aumenta.

f(n) puede ser cualquier función matemática que representa cómo varía el tiempo de ejecución con respecto al tamaño de entrada n.

Análisis teórico

El análisis teórico estima la eficiencia de un algoritmo sin ejecutarlo en una computadora.
Se basa en un estudio matemático que cuenta las operaciones que realiza el algoritmo según el tamaño de la entrada.
Generalmente se analiza el mejor caso, el caso promedio y, sobre todo, el peor caso para entender cómo crece su tiempo de ejecución.

Pasos en análisis teórico

Definir la operación básica: Se identifican las operaciones que consumen la mayor cantidad de tiempo en el algoritmo. Por ejemplo, en un algoritmo de búsqueda, la comparación de elementos puede ser la operación básicas.
Contar las operaciones: Se cuenta el número de veces que se realiza la operación básica en función del tamaño de entrada. Esto se hace siguiendo la lógica del algoritmo y analizando las iteraciones y repeticiones.
Expresar el tiempo de ejecución: Se expresa el número total de operaciones básicas en términos de la variable que representa el tamaño de entrada (por lo general, se denota como 'n'). Esto proporciona una ecuación matemática que representa cómo crece el tiempo de ejecución con respecto a 'n'.
Simplificar la ecuación: Se aplican técnicas matemáticas para simplificar la ecuación y eliminar términos insignificantes o de menor impacto.
Obtener la complejidad: Finalmente, se obtiene la complejidad del algoritmo en términos de notación asintótica, como el Big O, que describe cómo crece el tiempo de ejecución en el peor caso a medida que el tamaño de entrada se acerca a infinito.

El análisis teórico permite estimar la eficiencia de un algoritmo sin implementarlo ni ejecutarlo, lo que ayuda a comparar y elegir el algoritmo más adecuado para distintos problemas y tamaños de entrada. Sin embargo, no siempre refleja exactamente el rendimiento real, por lo que también es importante realizar pruebas prácticas (experimentación empírica).

Escenarios de Entrada

En el análisis de algoritmos, los escenarios de entrada se refieren a diferentes casos o situaciones que pueden ocurrir durante la ejecución de un algoritmo y que afectan su rendimiento. Estos escenarios de entrada ayudan a evaluar cómo se comporta el algoritmo en diferentes circunstancias y son importantes para comprender la eficiencia y la eficacia del algoritmo en general.

¿Qué sigue?

Peor caso: es el escenario en el que el algoritmo tiene el peor desempeño posible, con el mayor tiempo de ejecución o consumo máximo de recursos. Sucede cuando la entrada está en su forma más desfavorable y el algoritmo tiene que realizar un número máximo de operaciones.
Mejor caso: se refiere a la situación en la que el algoritmo tiene el mejor desempeño posible, es decir, el menor tiempo de ejecución o el menor uso de recursos. Este escenario se produce cuando la entrada está en su forma más favorable para el algoritmo y no se requiere realizar muchas operaciones.
Caso promedio: representa un escenario promedio en el que se consideran todas las posibles entradas del mismo tamaño y se toma en cuenta su probabilidad de ocurrencia. El rendimiento del algoritmo se evalúa tomando en cuenta la distribución de entradas posibles y el tiempo de ejecución promedio esperado.

Cotas de complejidad

Sea T(n) una función que representa el tiempo de ejecución de un algoritmo.

Big-O (Cota superior):

Decimos que:

Si existen constantes

Tales que:

Interpretación: El algoritmo NO crece más rápido que

T(n) = \mathcal{O}\left(f(n)\right)

c > 0 , n_0

T(n) \leq cf(n)

f(n)

Cotas de complejidad

Sea T(n) una función que representa el tiempo de ejecución de un algoritmo.

Big-Omega (Cota inferior):

Decimos que:

Si existen constantes

Tales que:

Interpretación: El algoritmo al menos tan rápido como

T(n) = \mathcal{\Omega}\left(f(n)\right)

c > 0 , n_0

T(n) \geq cf(n)

f(n)

Cotas de complejidad

Sea T(n) una función que representa el tiempo de ejecución de un algoritmo.

Big-Theta (Cota ajustada):

Decimos que:

Si existen constantes

Tales que:

Interpretación: el crecimiento es exactamente del orden de:

T(n) = \mathcal{\Theta}\left(f(n)\right)

c_1, c_2 > 0

c_1f(n)\leq T(n) \leq c_2f(n)

f(n)

Cotas de complejidad

\lim_{n \to \infty} \frac{T(n)}{f(n)} = \begin{cases} 0 & \Rightarrow T(n) = O(f(n)) \\ c>0 & \Rightarrow T(n) = \Theta(f(n)) \\ \infty & \Rightarrow T(n) = \Omega(f(n)) \end{cases}

Cálculo T(n)

Algoritmo A
  Entrada: n

  Para i ← 1 hasta n hacer
      x ← x + 1
  FinPara

FinAlgoritmo

Algoritmo B
  Entrada: n

  Para i ← 1 hasta n hacer
      Para j ← 1 hasta n hacer
          x ← x + 1
      FinPara
  FinPara

FinAlgoritmo

Cálculo T(n)

Algoritmo C
  Entrada: n

  Para i ← 1 hasta n hacer
      Para j ← 1 hasta i hacer
          x ← x + 1
      FinPara
  FinPara

FinAlgoritmo

Algoritmo Factorial(n)

  Si n = 1 entonces
      retornar 1
  FinSi

  retornar n * Factorial(n-1)

FinAlgoritmo

Cálculo T(n)

Algoritmo Suma(n)

  Si n = 1 entonces
      retornar 1
  FinSi

  retornar n + Suma(n-1)

FinAlgoritmo

Algoritmo Busqueda(n)

  Si n = 1 entonces
      retornar
  FinSi

  Busqueda(n/2)

FinAlgoritmo

Cálculo T(n)

Algoritmo Divide(n)

  Si n = 1 entonces
      retornar
  FinSi

  Divide(n/2)
  Divide(n/2)

FinAlgoritmo

Algoritmo Ejemplo(n)

  Si n = 1 entonces
      retornar
  FinSi

  Para i ← 1 hasta n hacer
      x ← x + 1
  FinPara

  Ejemplo(n/2)
  Ejemplo(n/2)

FinAlgoritmo