Las clases de complejidad son una manera de describir cuánto tiempo o recursos computacionales

requiere un algoritmo en función del tamaño de entrada. A continuación, te proporcionaré una

breve descripción de cada una de las clases de complejidad que has mencionado:

1. **O(1)** (Constant Time): Un algoritmo tiene una complejidad constante si su tiempo de

ejecución no cambia a medida que el tamaño de entrada aumenta. Ejemplos típicos son
operaciones aritméticas y acceso a elementos en un arreglo.

2. **O(n)** (Linear Time): Un algoritmo es lineal si su tiempo de ejecución crece de manera

proporcional al tamaño de entrada. Por ejemplo, recorrer una lista de elementos o buscar el
máximo en un arreglo.

3. **O(n^2)** (Quadratic Time): Los algoritmos cuadráticos tienen un tiempo de ejecución

proporcional al cuadrado del tamaño de entrada. Ejemplos incluyen bucles anidados, como
algoritmos de ordenamiento por selección o inserción.

4. **O(n^3)** (Cubic Time): Similar a la complejidad cuadrática, pero el tiempo de ejecución crece
en función del cubo del tamaño de entrada. Ejemplos menos comunes debido a su alta
complejidad.

5. **O(2^n)** (Exponential Time): Los algoritmos exponenciales tienen un tiempo de ejecución

que aumenta de manera exponencial con el tamaño de entrada. Suelen ser algoritmos ineficientes
para problemas más grandes. Ejemplos son el problema de la mochila resuelto con fuerza bruta y
algunos algoritmos de búsqueda exhaustiva.

6. **O(log n)** (Logarithmic Time): Los algoritmos logarítmicos tienen un tiempo de ejecución
que crece de manera logarítmica en relación al tamaño de entrada. Ejemplos incluyen búsquedas
en árboles binarios balanceados como el árbol AVL o el árbol binario de búsqueda.

7. **O(n log n)** (Linearithmic Time): Esta complejidad se encuentra comúnmente en algoritmos
eficientes de ordenamiento, como el algoritmo de ordenamiento rápido (quicksort) y el algoritmo
de ordenamiento por mezcla (merge sort).

8. **O(√n)** (Square Root Time): Algunos algoritmos tienen un tiempo de ejecución proporcional
a la raíz cuadrada del tamaño de entrada. Estos algoritmos son menos comunes, pero a veces
aparecen en problemas específicos.

9. **O(n!)** (Factorial Time): Los algoritmos factoriales tienen un tiempo de ejecución que crece
en función del factorial del tamaño de entrada. Esta es una complejidad muy alta y es típica de
algoritmos completamente ineficientes.

Es importante entender estas clases de complejidad para poder evaluar y diseñar algoritmos
eficientes en función de las demandas del problema y los recursos disponibles.
O(1): Complejidad constante. El tiempo de ejecución no depende del tamaño de entrada.

Ejemplo: Acceder a un elemento en un arreglo mediante su índice.

O(n): Complejidad lineal. El tiempo de ejecución crece linealmente con el tamaño de entrada.

Ejemplo: Recorrer todos los elementos de un arreglo para encontrar el máximo.

O(n^2): Complejidad cuadrática. El tiempo de ejecución crece cuadráticamente con el tamaño de

entrada.

Ejemplo: Algoritmo de burbuja para ordenar un arreglo.

O(n^3): Complejidad cúbica. El tiempo de ejecución crece cúbicamente con el tamaño de entrada.

Ejemplo: Algunos algoritmos de multiplicación de matrices.

O(2^n): Complejidad exponencial. El tiempo de ejecución crece de manera exponencial con el

tamaño de entrada.

Ejemplo: Algoritmos de fuerza bruta para resolver el problema del conjunto de subconjuntos.

O(log n): Complejidad logarítmica. El tiempo de ejecución crece de manera logarítmica con el
tamaño de entrada.

Ejemplo: Búsqueda binaria en un arreglo ordenado.

O(n log n): Complejidad linealítmica. El tiempo de ejecución crece linealmente multiplicado por el
logaritmo del tamaño de entrada.

Ejemplo: Algoritmo de ordenamiento rápido (QuickSort) y algoritmo de mezcla (MergeSort).

O(√n): Complejidad sublineal. El tiempo de ejecución crece más lentamente que linealmente pero
más rápido que logarítmicamente.

Ejemplo: Encontrar todos los divisores de un número.

O(n!): Complejidad factorial. El tiempo de ejecución crece factorialmente con el tamaño de

entrada.

Ejemplo: Algoritmos de generación de permutaciones completas.

Arrojar una cadena , con recursividad para verificar si una cadena es palíndromo

Elaborar un programa para obtener la serie de fubonaci con recursividad

 Ficha de jugador

Numero: int 4 bytes

Convocado: int 4 bytes
Goles: Int 4 bytes
T: int 4 bytes
Min. Jugados: int 4 bytes

Getnumer
getGoles
get…
get…
toString

Estadística

Fichadejuego: Vector < fichadejuego>

Nombre de equipo: String

Goles() int