Quais são alguns algoritmos que usamos diariamente que têm complexidades O (1), O (n log n) e O (log n)?

Se você quiser exemplos de Algoritmos / Grupo de Declarações com complexidade de Tempo, conforme fornecido na pergunta, aqui está uma pequena lista -

O(1) Tempo

• Acessando Índice de Matriz (int a = ARR [5];)
• Inserindo um nó na lista vinculada
• Empurrando e destacando na pilha
• Inserção e remoção da fila
• Descobrir o pai ou filho esquerdo / direito de um nó em uma árvore armazenada em Array
• Saltando para o próximo elemento / anterior na lista duplamente vinculada

O(n) Tempo

Em suma, todos os Algoritmos de Força Bruta, ou Noob que requerem linearidade, são baseados na complexidade de tempo O (n)

• Atravessando uma matriz
• Percorrendo uma lista vinculada
• Pesquisa Linear
• Exclusão de um elemento específico em uma lista vinculada (não classificado)
• Comparando duas strings
• Verificando Palíndromo
• Contagem / classificação de intervalo e aqui também você pode encontrar um milhão de exemplos mais ...

O(log n) Tempo

• Pesquisa Binária
• Encontrando o maior / menor número em uma árvore de pesquisa binária
• Certos algoritmos de divisão e conquista baseados na funcionalidade linear
• Calculando Números de Fibonacci - Melhor Método A premissa básica aqui NÃO é usar os dados completos e reduzir o tamanho do problema a cada iteração

O(n log n) Tempo

O fator de 'log n' é introduzido levando em consideração Dividir e Conquistar. Alguns desses algoritmos são os mais otimizados e usados ​​com frequência.

• Mesclar Classificar
• Classificação de pilha
• Ordenação rápida
• Certos algoritmos de divisão e conquista baseados na otimização de algoritmos O (n ^ 2)

O(n^2) Tempo

Supõe-se que esses algoritmos sejam os menos eficientes se suas contrapartes O (nlogn) estiverem presentes. A aplicação geral pode ser Força Bruta aqui.

• Tipo de bolha
• Ordem de inserção
• Ordem de Seleção
• Percorrendo uma matriz 2D simples

Um exemplo simples de O(1)pode ser return 23;- qualquer que seja a entrada, ela retornará em um tempo fixo e finito.

Um exemplo típico de O(N log N)classificação seria uma matriz de entrada com um bom algoritmo (por exemplo, mergesort).

Um exemplo típico O(log N)seria pesquisar um valor em uma matriz de entrada classificada por bissecção.

O (1) - a maioria dos procedimentos de cozimento são O (1), ou seja, leva uma quantidade de tempo constante, mesmo se houver mais pessoas para cozinhar (até certo ponto, porque você pode ficar sem espaço em suas panelas / frigideiras e precisa dividir a cozinha)

O (logn) - encontrar algo na lista telefônica. Pense em pesquisa binária.

O (n) - lendo um livro, onde n é o número de páginas. É o tempo mínimo necessário para ler um livro.

O (nlogn) - não consigo pensar imediatamente em algo que alguém possa fazer todos os dias que é nlogn ... a menos que você classifique os cartões por mesclagem ou classificação rápida!

Posso oferecer alguns algoritmos gerais ...

• O (1): Acessando um elemento em uma matriz (ou seja, int i = a [9])
• O (n log n): quick ou mergesort (em média)
• O (log n): Pesquisa binária

Essas seriam as respostas instintivas, pois isso soa como uma pergunta do tipo lição de casa / entrevista. Se você está procurando por algo mais concreto, é um pouco mais difícil, pois o público em geral não tem idéia da implementação subjacente (Poupança de código aberto, é claro) de um aplicativo popular, nem o conceito em geral se aplica a um "aplicativo"

O (1): encontrar o melhor próximo movimento no xadrez (ou no Go). Como o número de estados do jogo é finito, é apenas O (1) :-)

A complexidade do aplicativo de software não é medida e não é escrita em notação big-O. É útil apenas para medir a complexidade do algoritmo e comparar algoritmos no mesmo domínio. Muito provavelmente, quando dizemos O (n), queremos dizer que é "O (n) comparações " ou "O (n) operações aritméticas". Isso significa que você não pode comparar nenhum par de algoritmos ou aplicativos.

O (1) - Excluindo um elemento de uma lista duplamente vinculada. por exemplo

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


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

Você pode adicionar os seguintes algoritmos à sua lista:

O(1)- Determinar se um número é par ou ímpar; Trabalhando com HashMap

O(logN) - computando x ^ N,

O(N Log N) - A maior subsequência crescente

O (n log n) é notoriamente o limite superior de quão rápido você pode classificar um conjunto arbitrário (assumindo um modelo de computação padrão e não altamente paralelo).

0 (logn) - Pesquisa binária, elemento de pico em uma matriz (pode haver mais de um pico) 0 (1) - em python calculando o comprimento de uma lista ou string. A função len () leva 0 (1) tempo. O acesso a um elemento em uma matriz leva 0 (1) tempo. A operação push em uma pilha leva 0 (1) tempo. 0 (nlogn) -Merge sort. classificar em python leva tempo nlogn. portanto, quando você usa listname.sort (), leva tempo nlogn.

Observação: a pesquisa em uma tabela hash às vezes leva mais do que um tempo constante devido às colisões.

O (2 ^N )

O (2 ^N ) denota um algoritmo cujo crescimento dobra a cada adição ao conjunto de dados de entrada. A curva de crescimento de uma função O (2 ^N ) é exponencial - começando muito rasa, então aumentando meteoricamente. Um exemplo de uma função O (2 ^N ) é o cálculo recursivo dos números de Fibonacci:

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