¿Cuáles son algunos algoritmos que usamos a diario que tienen complejidades O (1), O (n log n) y O (log n)?

Si desea ejemplos de algoritmos / grupos de declaraciones con complejidad de tiempo como se indica en la pregunta, aquí hay una pequeña lista:

O(1) hora

• Accediendo a Array Index (int a = ARR [5];)
• Insertar un nodo en una lista vinculada
• Empujando y haciendo estallar en la pila
• Inserción y eliminación de la cola
• Encontrar el padre o el hijo izquierdo / derecho de un nodo en un árbol almacenado en Array
• Saltar al elemento siguiente / anterior en una lista doblemente vinculada

O(n) hora

En pocas palabras, todos los algoritmos de fuerza bruta, o los de Noob que requieren linealidad, se basan en la complejidad del tiempo O (n).

• Atravesando una matriz
• Atravesando una lista vinculada
• Búsqueda lineal
• Eliminación de un elemento específico en una lista vinculada (sin clasificar)
• Comparando dos cadenas
• Comprobación de palíndromo
• Counting / Bucket Sort y aquí también puede encontrar un millón de ejemplos más ...

O(log n) hora

• Búsqueda binaria
• Encontrar el número más grande / más pequeño en un árbol de búsqueda binaria
• Ciertos algoritmos de divide y vencerás basados ​​en la funcionalidad lineal
• Cálculo de números de Fibonacci: el mejor método La premisa básica aquí NO es usar los datos completos y reducir el tamaño del problema con cada iteración

O(n log n) hora

El factor de 'log n' se introduce considerando Divide y Conquista. Algunos de estos algoritmos son los mejor optimizados y se utilizan con frecuencia.

• Combinar ordenar
• Ordenar montón
• Ordenación rápida
• Ciertos algoritmos de divide y vencerás basados ​​en la optimización de algoritmos O (n ^ 2)

O(n^2) hora

Se supone que estos son los algoritmos menos eficientes si están presentes sus contrapartes O (nlogn). La aplicación general puede ser Brute Force aquí.

• Ordenamiento de burbuja
• Tipo de inserción
• Orden de selección
• Atravesando una matriz 2D simple

Un ejemplo simple de O(1)podría ser return 23;: cualquiera que sea la entrada, volverá en un tiempo fijo y finito.

Un ejemplo típico de O(N log N)sería ordenar una matriz de entrada con un buen algoritmo (por ejemplo, mergesort).

Un ejemplo típico O(log N)sería buscar un valor en una matriz de entrada ordenada por bisección.

O (1) - la mayoría de los procedimientos de cocción son O (1), es decir, lleva una cantidad constante de tiempo incluso si hay más personas para cocinar (hasta cierto punto, porque podría quedarse sin espacio en sus ollas / sartenes y necesito dividir la cocción)

O (logn): encontrar algo en su directorio telefónico. Piense en la búsqueda binaria.

O (n): leer un libro, donde n es el número de páginas. Es la cantidad mínima de tiempo que se necesita para leer un libro.

O (nlogn): no puedo pensar inmediatamente en algo que uno pueda hacer todos los días que sea nlogn ... ¡a menos que clasifique las tarjetas fusionando o clasificando rápidamente!

Puedo ofrecerte algunos algoritmos generales ...

• O (1): acceder a un elemento en una matriz (es decir, int i = a [9])
• O (n log n): clasificación rápida o combinada (en promedio)
• O (log n): búsqueda binaria

Estas serían las respuestas instintivas, ya que esto suena como una pregunta tipo tarea / entrevista. Si está buscando algo más concreto, es un poco más difícil, ya que el público en general no tendría idea de la implementación subyacente (código abierto, por supuesto) de una aplicación popular, ni el concepto en general se aplica a una "aplicación".

O (1): encontrar el mejor próximo movimiento en el ajedrez (o, para el caso, ir). Como el número de estados del juego es finito, es solo O (1) :-)

La complejidad de la aplicación de software no se mide y no se escribe en notación de O grande. Solo es útil para medir la complejidad del algoritmo y comparar algoritmos en el mismo dominio. Lo más probable es que cuando decimos O (n), queremos decir que se trata de "O (n) comparaciones " u "O (n) operaciones aritméticas". Eso significa que no puede comparar ningún par de algoritmos o aplicaciones.

O (1) - Eliminar un elemento de una lista doblemente enlazada. p.ej

typedef struct _node {
    struct _node *next;
    struct _node *prev;
    int data;
} node;


void delete(node **head, node *to_delete)
{
    .
    .
    .
}

Puede agregar los siguientes algoritmos a su lista:

O(1)- Determinar si un número es par o impar; Trabajando con HashMap

O(logN) - calculando x ^ N,

O(N Log N) - Subsecuencia creciente más larga

O (n log n) es el célebre límite superior de la rapidez con la que se puede ordenar un conjunto arbitrario (asumiendo un modelo informático estándar y no muy paralelo).

0 (logn) -Búsqueda binaria, elemento pico en una matriz (puede haber más de un pico) 0 (1) -en Python calculando la longitud de una lista o una cadena. La función len () tarda 0 (1) tiempo. Acceder a un elemento en una matriz toma 0 (1) tiempo. La operación de inserción en una pila toma 0 (1) tiempo. 0 (nlogn) -Merge sort. ordenar en Python toma tiempo nlogn. así que cuando usas listname.sort () toma nlogn tiempo.

La búsqueda de notas en una tabla hash a veces lleva más de un tiempo constante debido a las colisiones.

O (2 ^N )

O (2 ^N ) denota un algoritmo cuyo crecimiento se duplica con cada adición al conjunto de datos de entrada. La curva de crecimiento de una función O (2 ^N ) es exponencial: comienza muy poco profunda y luego aumenta de manera meteórica. Un ejemplo de una función O (2 ^N ) es el cálculo recursivo de números de Fibonacci:

int Fibonacci (int number)
{
if (number <= 1) return number;
return Fibonacci(number - 2) + Fibonacci(number - 1);
}