SóProvas



Questões de Complexidade de Algoritmos


ID
5434
Banca
CESGRANRIO
Órgão
Petrobras
Ano
2006
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

A respeito de funções e algoritmos, assinale a afirmativa correta.

Alternativas

ID
17842
Banca
CESGRANRIO
Órgão
BNDES
Ano
2008
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Se a complexidade de tempo de um algoritmo é da ordem de Θ (n log n), é correto afirmar que esse algoritmo também é

Alternativas
Comentários
  • Se tivermos uma lista de N números e quisermos encontrar algum deles assume-se que a complexidade no melhor caso é f(N) = ? (1), pois assume-se que o número estaria logo na cabeça da lista. Na questão o f(N) é f(n log n), portanto, ? (n log n)
  • ômega(g(n)) --> melhor casoTheta(g(n)) --> caso médioO(g(n)) --> pior casoSe eu sei que um algoritmo é do tipo ???(nlog(n)), posso afirmar que esse é também um algoritmo de Theta(nlog(n)). Ele também pode ser um algortimo de caso médio ou pior caso, porém mesmo que ele seja um algoritmo de caso médio ou pior caso, necessariamente ele deve também ser um algoritmo de melhor caso desse mesmo tipo. É um problema de raciocínio lógico e envolve o conhecimento das notações de melhor, médio e pior caso.
  • Essa questao deve ser feita por exclusão. A unica opcao que podemos ter como correta é a letra C
    Lembrando que Teta é Caso Medio; Omega é Melhor Caso e "o" maiusculo o Pior Caso.
    E a ordem crescente de compelxidade é: O(1); O(logn); O(n); O(nlogn); O(n^2) ...

    a) um algoritmo nao pode ter dois casos medios diferentes
    b) o melhor caso de um algoritmo nao pode ter complexidade maior que o caso medio
    c) podemos afirmar isso.
    d) o pior caso de um algoritmo nao pode ter complexidade melhor que o caso medio
    e) o pior caso de um algoritmo nao pode ter complexidade melhor que o caso medio
  • COMENTARIO DA 5


ID
27667
Banca
CESGRANRIO
Órgão
Petrobras
Ano
2004
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

A respeito de funções e algoritmos, assinale a afirmativa correta.

Alternativas
Comentários
  • a) Errado. O limite representado por ômega indica o melhor caso de sua execução. Indica a execução das instruções que só de depende do problema e não do algoritmo.
    b) Não sei...
    c)Errado. O é uma notação assintótica e não matemática. O O não pode ser elevado ao quadrado.
    d) Errado. Na soma prevalece o valor máximo, logo f(5*N^3 + 2*N^2) = O(n^3).
    e)Não sei o que é um limite superior justo...
  • Apenas acrescentando:b) Definição da Notação OSejam duas funções inteiras no domínio dos reais g(n) e f(n). Dizemos que g(n) é O(f(n)) se existem duas constantes positivas c e n0, tal que :1. 0 <= g(n) <= c.f(n), para todo n>= n0.Ou seja, podemos concluir que|g(n)| <= c.|f(n)|
  • e) O conceito de limite superior justo está ligado à notação Theta:

    Se f e g têm limite superior justo => f é Theta(g())

    Isso significa que f é O(g()) e f é Omega(g()). Além disso, g é O(f()) e g também é Omega(f()).
     
    Ou seja, cada uma destas funções é limite superior e inferior para a outra.
     
    A questão afirma que se duas funções possuem limite superior justo, uma é limite superior da outra, o que está incompleto, mas correto.
  • Uma função f(n) domina assintoticamente outra função g(n) se existem duas constantes positivas c e m tais que, para n ≥ m , temos |g(n)| c|f(n)|.

     

    Cobrar isso é brincadeira... 

  • Criei um grupo para quem quer ser aprovado em concursos rapidamente

    Aqui um ajuda o outro de graça e material de varios cursos bem selecionados

     

    Link do grupo (CopieCOLE) ---->  https://www.facebook.com/groups/ConcurseirosReciprocos/

  • Fui por eliminação.


ID
28579
Banca
CESGRANRIO
Órgão
DECEA
Ano
2006
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Seja T um texto e C, uma cadeia de caracteres, onde n e m correspondem ao tamanho de T e C, respectivamente. Sobre a busca de C em T, é correto afirmar que o algoritmo de:

Alternativas
Comentários
  • a) Força bruta sempre é o pior desempenho e não usa hash.b) KNP tem um algorítmo dividido em duas porções, com complexidades respectivas O(n) e O (k) e a complexidade do algorítmo é O (n+k)c) KNP não faz da direita para a esquerda e sim da esquerda para a direita.d) O pior caso do RK é O(nm)
  • Apenas estendendo o comentário anterior:

    a) Força bruta sempre é o pior desempenho e não usa hash. Sua complexidade no pior caso é de O(nm).

    b) Knuth-Pratt-Morris tem um algorítmo dividido em duas porções, com complexidades respectivas O(n) e O (k) e a complexidade do algorítmo é O (n+k). No pior caso aproxima-se à força-bruta O(mn)

    c) Knuth-Pratt-Morris não faz comparações da direita para a esquerda e sim da esquerda para a direita. Boyer-Moore é que faz comparações da direita para a esquerda;


    d) A complexidade do Rabin-Karp é, em média, de O(n+m) a O(nm). No pior caso é de O( (n – m +1)m ), praticamente o mesmo caso de Boyer-Moore para o pior caso.

    e) Boyer-Moore utiliza heurísticas conhecidas como a “heurística-do-bom- sufixo” e a “heurística-do-mau-caractere”. (CORRETO)

  • De quem bibiliografia vocês tiraram esses autores de algorítmos?
  • A abordagem de Boyer-Moore é tentar combinar o último caractere do padrão em vez do primeiro com a suposição de que, se não houver correspondência no final, não é necessário tentar combinar no início. Isso permite "grandes saltos", portanto o BM funciona melhor quando o padrão e o texto que você procura são semelhantes a "texto natural" (isto é, inglês)

     

    Knuth-Morris-Pratt procura as ocorrências de uma "palavra" W dentro de uma "string de texto" principal, empregando a observação de que, quando ocorre uma falta de correspondência, a própria palavra incorpora informações suficientes para determinar onde a próxima partida poderia começar, ignorando assim a re-examinação de caracteres anteriormente correspondentes. (Fonte: Wiki)

    Isso significa que o KMP é mais adequado para conjuntos pequenos como o DNA (ACTG)

     

    https://pt.stackoverflow.com/questions/231105/qual-%C3%A9-a-diferen%C3%A7a-principal-entre-os-algoritmos-knuth-morris-pratt-e-boyer-moor

  • Controle Externo - Luiz Henrique Lima (o mais utilizado)


ID
137215
Banca
CESGRANRIO
Órgão
Casa da Moeda
Ano
2009
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

No desenvolvimento de um sistema de análise financeira, um programador utilizou um algoritmo cuja complexidade de tempo, no pior caso, é igual a O(n).
Outro programador aponta um algoritmo de melhor complexidade igual a

Alternativas
Comentários
  • Volto a dizer:

    A ordem de cima ai esta errada. O correto é:

    O(1) -> O(logn) -> O (n) -> O (nlog n) -> O(n^2) -> O (n^3) -> O (2^n ) -> O (n!)
  •  

    O examinador passou o valor (n) e quer um algoritmo de melhor complexidade, ou seja, quer um algoritmo mais eficiente que (n).

     

    (A) O(log n).(ao analisar a tabela abaixo constata-se que (logn) é o MENOS complexo e mais eficiente entre os citados.)
    (B) O(n log n).
    (C) O(n2)
    (D) O(2n)
    (E) O(n!)

     

    --------------------------------------------------------------------------------------------------------------------------------------

    A tabela que tem que ter tatuada no cerebro:

     

    CONSTANTE  | LOGARITMO | LINEAR  | NLOGN  | quadrática    |cúbica | EXPONENCIAL
    1                      | logn                | n             | nlogn     | n2                  |n3        | an

     

    OBS1. A complexidade vai aumentando, ou seja, CONSTANTE 1 é a menos complexa, já a exponencial é a mais complexa.

    OBS2. A eficiência vai diminuindo, ou seja, CONSTANTE 1 é a mais eficiente, já a exponencial é a menos eficiente.

    --------------------------------------------------------------------------------------------------------------------------------------

     


ID
142219
Banca
CESGRANRIO
Órgão
BNDES
Ano
2009
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Seja n o tamanho da entrada de um algoritmo para um problema P. Cada alternativa, que corresponde a um algoritmo distinto, apresenta o número de operações necessárias para resolver P. Considerando-se a análise assintótica (Big O notation), qual algoritmo possui menor complexidade?

Alternativas
Comentários
  • A ordem de cima ai esta errada. O correto é:

    O(1) -> O(logn) -> O (n) -> O (nlog n) -> O(n^2) -> O (n^3) -> O (2^n ) -> O (n!)
  • Lembrando que:
    • O(2 + 10log n) = O(log n)
    • O(3n2+n) = O(n2)
    • O(1000+2n3) = O(n3)
    • O(5n+128) = O(n)
    • O(4n)
    Em ordem crescente de complexidade temos:
    • O(log n) < O(n) < O(n2) < O(n3) < O(4n)
  • Ilustrando os comentários acima:
  • Cabe colocar também algumas das principais estruturas de dados/algoritmos de busca quanto à sua complexidade:
  • Simplificando :

    (A) 2 + 10log n - Complexidade logarítmica

    (B) 3n2 + n - Complexidade quadrática

    (C) 1000 + 2n3 - Complexidade cúbica

    (D) 5n + 128 - Complexidade linear

    (E) 4n    - Complexidade exponencial

    A resposta correta é letra (A), pois dentre as complexidades das alternativas da questão a logarítmica é a menor.
    Como informa a tabela do colega acima postada.


  • 1 PASSO: eliminar os números (eliminação em vermelho):

    (A) 2 + 10logn
    (B) 3n2 + n
    (C) 1000 + 2n3
    (D) 5n + 128
    (E) 4n

     

    2 PASSO: eliminar as funções menos complexas em detrimento as mais complexas (eliminação em negrito):

    (A) 2 + 10logn
    (B) 3n2 + n (OBSERVE AQUI QUE O MAIS COMPLEXO SEMPRE ELIMINARÁ O MENOS COMPLEXO, PORTANTO O n ta FORA)
    (C) 1000 + 2n3
    (D) 5n + 128
    (E) 4n

     

    3 PASSO: Analisar os resultados e assinalar qual é o mais complexo:

    (A) 2 + 10logn ----> logn (ESSE É O RESULTADO COM A FUNÇÃO MENOS COMPLEXA, PORTANTO É O GABARITO)
    (B) 3n2 + n ---> n2
    (C) 1000 + 2n3 ---> n3
    (D) 5n + 128 ---> n
    (E) 4n ---> 4n

     

    --------------------------------------------------------------------------------------------------------------------------------------

    A tabela que tem que ter tatuada no cerebro:

     

    CONSTANTE  | LOGARITMO | LINEAR  | NLOGN  | quadrática    |cúbica | EXPONENCIAL
    1                      | logn                | n             | nlogn     | n2                  |n3        | an

     

    OBS. A complexidade vai aumentando, ou seja, CONSTANTE 1 é a menos complexa, já a exponencial é a mais complexa

    --------------------------------------------------------------------------------------------------------------------------------------


ID
163069
Banca
CESGRANRIO
Órgão
Petrobras
Ano
2010
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Uma lista ordenada de N números é inserida em uma pilha e depois retirada, sendo que, a cada POP, o elemento retirado é inserido em uma árvore de busca binária. Após a completa inserção de todos os elementos nesta árvore, são feitas buscas de números na mesma. O tempo médio de busca de um número nesta árvore é

Alternativas
Comentários
  • Letra C

    Quando forma removidos da pilha os números voltaram em ordem decrescente.
    Se inserir um lista decrescente em um arvore, teremos um árvore com um único ramo, semelhante a uma lista encadeada. A busca nessa estrutura é de ordem O(N)
  • Então o pior caso da busca binaria deveria ser O(n). Porem vi em muitas referencias que o pior caso é O(log n). Agora fiquei na duvida.
  • Oi Bruno!! O que acontece é que os elementos da pilha foram inseridos de forma linear na arvore, por isso é que a resposta é O(n).
    No caso da arvore binaria de pesquisa completa e balanceada a complexidade é esta que você disse O(log n).
  • Questão bem bolada que engana fácil se não estiver firme nos conceitos. Em uma árvore de busca binária balanceada, por definição, os elementos menores estão à esquerda de um nó e os maiores, à direita. Além disso, por ser balanceada (AVL), as alturas das duas sub-árvores a partir de cada nó diferem nó máximo em uma unidade. Desta forma, a complexidade de busca é O(log n) na base 2. Em outras palavras, a cada vez que dobra a quantidade de elementos, o número de operações de busca aumenta em um. Como nesta árvore os números foram inseridos a partir de uma pilha ordenada, a cada inserção - do maior para o menor valor - os nós posicionaram-se a esquerda do nó pai, formando uma árvore de um único ramo, ou seja, uma árvore que não está balanceada. Nestas condições, a busca se torna sequencial, sendo necessário, no pior caso, percorrer todos os elementos da árvore - O(n).

  • A primeira informação é que temos uma lista ordenada e cada elemento dessa lista é retirado e inserido em uma pilha, logo após são retirados da pilha, com isso obtemos a lista em ordem inversa, se inserirmos essa lista inversa em uma árvore obtemos uma árvore degenerada que tem complexidade de tempo O(N). Logo, resposta letra C)


ID
226267
Banca
CESGRANRIO
Órgão
EPE
Ano
2010
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Um programador decidiu utilizar, em determinado sistema de análise estatística, uma árvore AVL como estrutura de dados. Considerando-se n a quantidade de elementos dessa árvore, o melhor algoritmo de pesquisa, com base em comparações, possui complexidade de tempo, no pior caso, igual a

Alternativas
Comentários

  • A propósito, o simbolo da ferradura (ÔMEGA) refer-se ao melhor caso, o do sandwich (TETA) ao caso médio e o BIG-O , O(n) ao pior caso.

    A  árvore AVL é uma árvore binária de busca balanceada.

    Árvores binárias de busca não balanceadas podem - no pior caso - crescer apenas para um lado transformando-se em uma lista. Nesse caso o tempo de busca torna-se O(n), onde n é o tamanho da lista.

    No caso da arvore AVL, que garante uma árvore com fator de desbalanceamento no máximo 1, isto á  | alturaDaSubarvoreDireita - alturaDaSubarvoreEsquerda | <= 1 , para todos os nós, o pior caso do algoritmo torna-se O( log n), ou seja, o elemento procurado é uma folha da arvore, e a altura de uma arvore de n elementos é log n.

    OBS: log n , sendo log na base 2, não na base 10.
  • A complexidade no pior caso a árvore AVL é  O( log n)


ID
325369
Banca
FUNCAB
Órgão
SEJUS-RO
Ano
2010
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Considere um arquivo não ordenado, organizado sequencialmente e contendo N registros.O número médio de acessos que precisa ser feito para localizar um registro nesse arquivo, numacesso sequencial é:

Alternativas
Comentários
  • Se a busca é sequencial, o melhor caso é encontrar na pesquisa 1. O pior caso é na pesquisa N. Logo a média é N / 2.
  • Se fosse pela média, o resultado seria (N+1)/2, não?
    A resposta é N/2 por esse ser o caso médio da complexidade do algoritmo.
    Mas, na minha opinião, essa questão está incompleta, pois para o caso médio deve-se pressupor conhecida uma certa distribuição de entrada. A única que fala é que o arquivo não está ordenado, mas não afirma que, por exemplo, a distribuição dos registros é uniforme ou que todos os valores das buscas foram encontrados no arquivo. Essas duas condições impactariam consideravelmente o caso médio do algorimo, e consequentemente o numero médio de acessos do mesmo.
  • A questão é simples. Pesquisa sequencial, como o próprio nome diz, significa buscar em sequência, do primeiro ao último elemento. Como são N registros, em média será necessário acessar a metade, ou seja, N/2.

ID
425128
Banca
COPEVE-UFAL
Órgão
UFAL
Ano
2011
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

tempo de execução do pior caso do algoritmo de ordenação Quicksort é:

Alternativas
Comentários
  • a complexidade de pior caso do algoritmo quicksort é O(n2).
    Já o tempo de execução não há como saber, depende de uma série de fatores, entre eles:
    • Tamanho da entrada
    • Arquitetura na qual o algoritmo é executado
    • Concorrência com outros processos
    • etc...
  • A complexidade no caso médio (Teta) para o QuickSort é n log n.
    Para o pior caso é O(n^2).

  • O quick sort têm tempo médio n log n, mas em casos específicos(pior caso) leva n^2.

    Apesar de ser lento apenas em caso específicos, o caso específico não deixa de ser comum. Em implementações comuns o algoritmo se comporta mal justamente quando uma lista já está ordenada, algo que não é incomum.Apesar de existirem diversos algoritmos com temo n log n, o quicksort é um dos mais velozes no caso médio, por isso ainda é muito utilizado.

    Imagino que a questão foi anulada por falar em tempo de execução ao invés de complexidade. Um problema que talvez fosse ignorado por muitas bancas.

     

     


ID
464164
Banca
CESGRANRIO
Órgão
Transpetro
Ano
2011
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Dois vetores ordenados, contendo, cada um deles, N números inteiros, precisam ser unidos em outro vetor maior, que conterá os 2N números, que também serão armazenados de forma ordenada. A complexidade de tempo de melhor caso desse processo será, então,

Alternativas
Comentários
  • A questão descreve um trecho da funcionalidade do algoritmo MergeSort, e o trecho descrito é justamente na hora de juntar os pedaços do vetor que foi dividido e ordenado recursivamente.

    Pode-se utilizar, no trecho descrito, a busca binária para determinar a posição onde os elementos do primeiro vetor serão colocados em relação ao segundo vetor. Porém, a questão erra nesse ponto, afirmando o seguinte: b) "O(log N), pois se usa a busca binária para determinar qual será o próximo elemento copiado para o vetor de destino". O(log N) de fato é a complexidade de uma busca binária, mas o objetivo dessa busca não é determinar qual o próximo elemento a ser copiado, e sim onde o proximo elemento será posicionado.

    Por outro lado, esse trecho do algoritmo também pode ser implementado com uma simples busca sequêncial como está descrito na letra C e sua complexidade será justamente O(N).

    A busca binária é a melhor escolha para implementar esse "Merge" mas a questão não pergunta isso, ela confunde ao perguntar "A complexidade de tempo de melhor caso desse processo será, então,". Como os dois vetores estão ordenados, uma busca sequêncial será executada sempre no melhor caso, efetuando sempre N comparações, dai pode-se afirmar que a complexidade desse processo é O(N). Se os vetores não estivessem ordenados, a complexidade desse processo seria O(N²).

    Resumindo, a alternativa B seria a certa se sua descrição estivesse correta.
  • creio que o colega esteja errado,

    de qualquer modo, no melhor caso (o caso em tela, visto que ambos vetores já estão ordenados) será necessário realizar 2N cópias para o vetor final, o que resultaria em uma complexidade de melhor caso de O(2N) = O(N)

    se eu realizasse uma busca binária, para cada elemento do vetor 1 (que contem N elementos) eu deveria encontrar um vetor menor (ou mesmo não encontrar) no vetor 2 usando busca binária (complexidade O(log N)). Complexidade final: O(N * log N)

    não sou um matemático, então corrijam-me se me enganei
  • Na época eu caí na casca de banana. Lembrei logo do MergeSort, vi que a letra D tinha a complexidade do MergeSort e marquei logo de cara. Até hoje não compreendi direito por que a resposta não pode ser a letra D, se ela em exatamente a complexidade do MergeSort.
    Desculpem a pergunta idiota, porque vendo a resposta de vocês eu até concordo que irá percorrer no máximo 2N posições. O que não entra na minha cabeça é o fato de a questão estar associada ao algoritmo MergeSort e da resposta não ser a complexidade dele.
  • Gente, a questão perguta qual a complexidade no melhor caso. Sabemos que quando os dados (elementos) a serem ordenados já estão praticamente ordenados, os algorítimos de inserção são os mais eficientes. Para n, onde n é o número de valores a serem ordenados e que os valores já estejam ordenados, os algoritimos recomendados são os algorítmos de complexidade quadrática, que no melhor caso tem complexidade linear => O(n). São exemplos de algoritimos de ordenação que teriam complexidade O(n) nesse caso: Insertion Sort, Bubble Sort e Shell Sort. Nesse caso, utilizar algoritimos sofisticados como Quicksort, Mergesort ou Heapsort seria bobagem, pois no melhor caso eles apresentariam somente O(n log n).

    Espero ter contribuido! Bons estudos!
  • Nelson, obrigada por sua resposta.

    Agora entendi por que a resposta é O(N) e não O(N log N).


ID
582664
Banca
FCC
Órgão
TRT - 19ª Região (AL)
Ano
2011
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Considere os seguintes algoritmos e suas complexidades na notação Big O:

- Algoritmo A: O(log n)
- Algoritmo B: O(n2)
- Algoritmo C: O(n . log n)

Considerando-se o pior caso de execução destes algo- ritmos, é correto afirmar que o algoritmo

Alternativas
Comentários
  • Para quem nunca tinha ouvido falar desta notação, assim como eu.... ai vai....

    Notação O Grande (também conhecida como big O notation, no inglês , notação Landaunotação Bachmann–Landau e notação assintótica) descreve o comportamento limitante de uma função quando o argumento tende à um determinado valor ou ao infinito, geralmente em termos de funções mais simples. A notação O Grande Big permite que seus usuários simplifique funções para que se concentrem em suas taxas de crescimento: Funções diferentes com a mesma taxa de crescimento podem ser representadas usando a mesma notação O. 
    Apesar de ser desenvolvida como parte da matemática pura, atualmente esta notação é comumente utilizada na análise de algorítimos para descrever o uso de recursos computacionais realizado por um determinado algoritmo a partir da análise da complexidade do tempo de execução utilizando a análise do pior casocaso médio ou melhor caso.
  • Resposta certa: letra D

    A complexidade de algoritmos é muito importante para avaliar o tempo de execução de qualquer algoritmo. Para responder a questão podemos considerar, por exemplo, n = 100.
    Então:

    algoritmo A -> O(log n) = log 100 = 2, onde a base é 10, 10² = 100;

    algoritmo B -> O(n²) = 100² = 10000;

    algoritm C -> O(n log n ) = 100 log 100 = 100x2 = 200,   
    Logo, tempo de B >  tempo de C >  tempo de A, B é o que tem a pior eficiência.

  • Uma pequena "correção" na resposta do colega Caracol (que não invalida de forma alguma a argumentação dele).

    A complexidade O(log n) se refere à base 2, e não à 10.

    Alguns exemplos de algoritmos que possuem complexidade O(log n) são as buscas binárias e buscas em uma árvore binária de busca que esteja balanceada (árvores binárias não balanceadas vão ter complexidade no pior caso de O(n)).
    Essa complexidade é conseguida, no caso das buscas, em sempre "eliminar" a metade do total atual da lista em uma única iteração, ou seja, na primeira iteração elimina 50% do total, na segunda 75% (50% + 25%), terceira 87,5%(50% + 25% + 12,5%) e assim vai até achar o resultado. Dessa forma o número máximo de iterações sempre será, no pior caso, um logarimo na base 2 de n, onde n é igual ao número máximo de elementos contidos na lista.
    Por exemplo, realizar uma busca binária em um vetor de 8 posições. Na primeira iteração serão eliminados 4 valores, na segunda 2 e na terceira 1. Caso não seja achado o valor o algoritmo terminará, pois não haverá mais nem um campo a ser pesquisado. Então a complexidade dessa busca é no pior caso de 3 iterações, que é exatamente o valor de log8 na base 2. Pois 2³ = 8.
    Vale ressaltar que para ser possível alguma forma de pequisa binária a lista deve estar ordenada.

    Nesse link abaixo contém uma boa apostila sobre complexidade de algoritmos.
    http://www.ime.usp.br/~song/mac5710/slides/01complex.pdf
  • Pessoal,

    Pelas alternativas e pela figura do link abaixo percebemos que o algoritmo B é polinomial, ou seja, é o menos eficiente ou mais complexo:

    https://dl.dropbox.com/u/71196419/ComplexidadeAlgoritmos.jpg

  • Ordenando-os por eficiência:

    1 Algoritmo A: O(log n)  

    2 Algoritmo C: O(n . log n)  

    3 Algoritmo B: O(n2) 

    O A é visivelmente mais eficiente pq é o valor de A multiplicado por N, ou seja: C é N vezes maior que A.


     

  • - Algoritmo A: O(log n)                      -----> logn (MAIS EFICIENTE DAS 3)
    - Algoritmo B: O(n2)                          -----> n2 (MENOS EFICIENTE DAS 3)
    - Algoritmo C: O(n . log n)                 -----> nlogn ( TA NO MEIO)

     

    (A) A é o menos eficiente. (É O MAIS EFICIENTE)
    (B) C é o menos eficiente. (E A MENOS EFICIENTE)
    (C) A não é o mais eficiente nem o menos eficiente. (É A MAIS EFICIENTE)
    (D) B é o menos eficiente. (CORRETO!!!!)
    (E) C é o mais eficiente. (É A MENOS EFICIENTE)

     

    --------------------------------------------------------------------------------------------------------------------------------------

    A tabela que tem que ter tatuada no cerebro:

     

    CONSTANTE  | LOGARITMO | LINEAR  | NLOGN  | quadrática    |cúbica | EXPONENCIAL
    1                      | logn                | n             | nlogn     | n2                  |n3        | an

     

    OBS1. A complexidade vai aumentando, ou seja, CONSTANTE 1 é a menos complexa, já a exponencial é a mais complexa.

    OBS2. A eficiência vai diminuindo, ou seja, CONSTANTE 1 é a mais eficiente, já a exponencial é a menos eficiente.

    --------------------------------------------------------------------------------------------------------------------------------------


ID
606163
Banca
CESGRANRIO
Órgão
FINEP
Ano
2011
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Considerando-se a análise assintótica (Notação Big O), qual é a complexidade do caso médio do algoritmo de ordenação chamado de Ordenação por Inserção?

Alternativas
Comentários
  • Questão classificada erroneamente.
  • Detalhes: http://pt.wikipedia.org/wiki/Insertion_sort

    Complexidade do caso médio do Insertion Sort (algoritmo de Ordenação por Inserção = O(n²)

    Insertion sort, ou ordenação por inserção, é um simples algoritmo de ordenação, eficiente quando aplicado a um pequeno número de elementos. Em termos gerais, ele percorre um vetor de elementos da esquerda para a direita e à medida que avança vai deixando os elementos mais à esquerda ordenados. O algoritmo de inserção funciona da mesma maneira com que muitas pessoas ordenam cartas em um jogo de baralho como o pôquer.
  • A complexidade de tempo do caso médio é igual a do pior caso. Lembrando que a Complexidade temporal de um algoritmo se dá em função do tamanho (n) da entrada. 

    Já a Ordenação por Partição é O(n log n). 


  • Questão errada. Cabe recurso.

  • Gabarito A

    INSERÇÃO DIRETA ---> complexidade pior n2 e complexidade melhor n.

     

     

     

    "Retroceder Nunca Render-se Jamais !"
    Força e Fé !
    Fortuna Audaces Sequitur !

  • algo____________best___________average___________worst

    Quicksort   Ω(n log(n))___________   Θ(n log(n))___________   O(n^2)   

    Mergesort   Ω(n log(n)) ___________  Θ(n log(n)) ___________  O(n log(n))   

    Timsort   Ω(n) ___________  Θ(n log(n)) ___________  O(n log(n))   

    Heapsort   Ω(n log(n))___________   Θ(n log(n)) ___________  O(n log(n))

    Bubble Sort   Ω(n) ___________  Θ(n^2)  ___________ O(n^2)

    Insertion Sort   Ω(n) ___________  Θ(n^2)  ___________ O(n^2)

    Selection Sort   Ω(n^2) ___________  Θ(n^2)  ___________ O(n^2)

    Tree Sort   Ω(n log(n))  ___________ Θ(n log(n))  ___________ O(n^2)

    Shell Sort   Ω(n log(n))  ___________ Θ(n(log(n))^2)  ___________ O(n(log(n))^2)

    Bucket Sort   Ω(n+k)  ___________ Θ(n+k)  ___________ O(n^2)

    Radix Sort   Ω(nk)  ___________ Θ(nk)  ___________ O(nk)

    Counting Sort   Ω(n+k)  ___________ Θ(n+k)  ___________ O(n+k)

    Cubesort   Ω(n)   ___________Θ(n log(n))  ___________ O(n log(n))   


ID
638152
Banca
FUMARC
Órgão
PRODEMGE
Ano
2011
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

São algoritmos de ordenação, cuja complexidade é O(n log n), EXCETO:

Alternativas
Comentários
  • O pior caso do shell sort é O(n log n) e não O(1) como o ML escreveu acima.
  • Para o caso médio, temos que a complexidade do Radix Sort é dada por Q((b/r)(n+2r)), onde n é a quantidade de números, b é a quantidade de dígitos e r é um inteiro positivo qualquer, tal que r <= b.
     
  • Cabe anulação nesta questão. Os únicos algorítmos que possuem complexidade de O(n log n) em todos os casos são Heapsort e MergeSort.
     
    QUICKSORT:
    • Melhor caso: O(N log N)
    • Caso Médio: O(N log N)
    • Pior caso: O(N^2) – ARQUIVO JÁ CLASSIFICADO
     
    HEAPSORT:
    • Melhor caso: O(N log N)
    • Caso Médio: O(N log N)
    • Pior caso: O(N log N) 
     
    SHELLSORT (Refinamento do Insertionsort)
    • Melhor caso: O(N)
    • Caso Médio: Depende da sequência do GAP.
    • Pior caso: O(N log^2 N)
  • O Radixsort é um método de ordenação por contagem que é executado em tempo linear O(n).
  • O radix sort LSD opera na notação Big O, em O(nk), onde "n" é o número de chaves, e "k" é o comprimento médio da chave. É possível garantir esse desempenho para chaves com comprimento variável agrupando todas as chaves que tem o mesmo comprimento e ordenando separadamente cada grupo de chaves, do mais curto para o mais comprido, de modo a evitar o processamento de uma lista inteira de chaves em cada passo da ordenação.

    Em muitas aplicações em que é necessário velocidade, o radix sort melhora as ordenações por comparação, como heapsort e o mergesort, que necessitam de Ω(n · log n) comparações, onde "n" é o número de itens a serem ordenados. Em compensação, algoritmos de ordenação baseados em comparações oferecem flexibilidade por serem aptos a ordenar de outras formas que não a lexicográfica. No entanto, essa habilidade é de pouca importância em várias aplicações práticas.

  • Acho que essa questão cabe anular sim.

    Olha o estudo detalhado de como é calculado a complexidade dos algoritmos.

    http://www.decom.ufop.br/menotti/aedI082/tps/tp3-sol1.pdf

  • Curiosidade: RadixSort é o método de ordenação usado pelos Correios para ordenar as cartas por CEP.

  • Não tem nada de anulação nessa questão!
    Complexidade  = Inserção  O(n 2 );  | Seleção  O(n 2 );  |  Shellsort  O(n log n);  |  Quicksort  O(n log n);  | Heapsort  O(n log n).
               Apesar de não se conhecer analiticamente o comportamento do Shellsort, ele é considerado um método eficiente).

          radixsort
    O algoritmo de ordenação radix foi originalmente usado para ordenar cartões perfurados.

    Complexidade de Tempo: O(nk).

    Complexidade de espaço: O(n + s).

    fonte: https://pt.wikipedia.org/wiki/Radix_sort




  • LETRA  D

    Só lembrar que o RADIX SORT é o diferentão da galera. Ele apresenta K(Tamanho da String) e S(Tamanho do Alfabeto)

    Complexidade de Tempo: O(nk)
    Complexidade de espaço: O(n + s)

  • d-

    o radix sort é usadso para ordenar algortimos identificados por um chave unica, sendo cada chave é um string ou um nome consoante a ordem lexicografica.

    https://www.bigocheatsheet.com/


ID
705181
Banca
UPENET/IAUPE
Órgão
JUCEPE
Ano
2012
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Sobre a complexidade de algoritmos, analise os itens abaixo:
I. Se o número de passos realizados por um algoritmo A é (n2 + n) para várias entradas de tamanho n, então a complexidade de A é O(n2 ).
II. Se a complexidade de pior caso de um algoritmo A for n, então o número de passos efetuados por A é O(n), qualquer que seja a entrada.
III. Se a complexidade de pior caso de um algoritmo A for n, então podemos afirmar que A é O(n) e também O(n2 ), mas a afirmação O(n) é mais precisa e deve ser utilizada.

Assinale a alternativa CORRETA.

Alternativas
Comentários
  • q? como assim?

  • que la ela viu bixo ! 

  • Essa questão tá errada, não tem condições! A alternativa I está correta, alguém me corrija por favor.

  • @Igor Alisson acredito que seja (N²-N)/2

  • c-

    A (n2 + n) nao pode ser complex. O(n²).

    n=2

    (4+2)=6

    ______________________________________________________________________________________________________________

    n=3

    (9+3)=12

    ______________________________________________________________________________________________________________

    n=4

    (16+4)=20

    ______________________________________________________________________________________________________________

    o aumento de passos é linear, e nao exponencial

  • Notifiquei o erro da questão, não é possível isso


ID
705184
Banca
UPENET/IAUPE
Órgão
JUCEPE
Ano
2012
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

 Sabe-se que o valor de um dado armazenado com um tipo inteiro é o próprio número inteiro na base binária que forma uma cadeia de bits. A largura (ou precisão) de um tipo inteiro é a quantidade de bits disponíveis para a sua representação. O algoritmo abaixo avalia a quantidade de bits necessária para armazenar um inteiro. Determine sua complexidade. 
int numero_bits (int x) {
               int bits = 0;
               while (x != 0) { bits++; x=x/2; }
               return bits;

Alternativas
Comentários
  • x=x/2 --> Logaritmico

  •  
    Logaritmo - O(log n) : Ocorre tipicamente em algoritmos que dividem problemas em problemas menores. Ex: Algoritmo de busca binária, buscar um elemento em um vetor ordenado;


ID
754495
Banca
Marinha
Órgão
Quadro Complementar
Ano
2011
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Em relação às classes de complexidade de problemas, assinale a opção correta.

Alternativas
Comentários
  • a) A classe de problemas em P consiste nos problemas que dado um "certificado" de uma solução, é possível verificar se a solução é correta em tempo polinomial no tamanho da entrada.

    ERRADO. Essa é a definição da classe NP

     b) A classe de problemas NP consiste nos problemas que não pertencem a classe P, e por isso são problemas não "verificáveis" em tempo polinomial.

    ERRADO. A classe NP contém a classe P e é a classe de problemas verificáveis em tempo polinomial, segundo a definição em a).

     c) A busca binária é um problema em NP-completo, dependendo do tamanho da entrada.

    ERRADO. A busca binária é um problema da classe P, pois possui complexidade O(log n)

     d) Um problema que está em P não estará em NP, exceto problemas NP-completos, os quais não foram demonstrados pela ciência.

    ERRADO. A classe P está contida em NP.

     e) Dado que exista um problema NP-completo com solução em tempo polinomial, então todos os problemas em NP terão soluções em tempo polinomial.

    CERTO.  Dentro da classe NP-completo, todos os problemas podem ser reduzidos uns aos outros. Logo, se algum deles tiver solução em tempo polinomial, todos terão.


ID
754561
Banca
Marinha
Órgão
Quadro Complementar
Ano
2011
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Analise as informações a seguir

Algoritmo: Rearranja o vetor A[ p..r] em ordem crescente, supondo p≤r QuickSort(A, p, r)
1- se p< r
2- então q < - Particione (A,p, r)
3- QuickSort (A,p, q-1)

4- QuickSort (A, q+ 1, r)
Em uma análise do consumo máximo de tempo do algoritmo QuickSort, considerando a função Particione com desempenho EN, qual é o consumo de tempo no pior caso? Considere n igual ao número máximo de elementos.

Alternativas
Comentários
  • O gabarito é a letra D.

     

    Complexidade no Pior Caso: O(n^2)

    Complexidade no Caso Médio: O(n log n)

    Complexidade no Melhor Caso: O(n log n)


ID
759355
Banca
PaqTcPB
Órgão
UEPB
Ano
2012
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Busca ou pesquisa binária é um algoritmo de busca em vetores ordenados. Sobre o algoritmo de busca binária é correto afirmar:

I - No pior caso tem complexidade O(log n).

II - No melhor caso tem complexidade O(log n).

III - No caso médio tem complexidade O(1).

IV - No melhor caso tem complexidade O(n).

Está(ão) correta(s)

Alternativas
Comentários
  • pesquisa ou busca binária (em inglês binary search algorithm ou binary chop) é um algoritmo de busca em vetores que segue o paradigma de divisão e conquista. Ela parte do pressuposto de que o vetor está ordenado e realiza sucessivas divisões do espaço de busca comparando o elemento buscado (chave) com o elemento no meio do vetor. Se o elemento do meio do vetor for a chave, a busca termina com sucesso. Caso contrário, se o elemento do meio vier antes do elemento buscado, então a busca continua na metade posterior do vetor. E finalmente, se o elemento do meio vier depois da chave, a busca continua na metade anterior do vetor.

    caso médio: {O}(\log n)
    melhor caso: {O}(1)
    pior caso: {O}(\log n)

    http://pt.wikipedia.org/wiki/Pesquisa_bin%C3%A1ria
  • O pior caso não seria O(n)?

  • complexidade caso médio : O(log n)

    complexidade melhor caso : O(1)

    complexidade de pior caso : O(log n)

  • Força Guerreiro!!!!!!


ID
769330
Banca
CESPE / CEBRASPE
Órgão
Banco da Amazônia
Ano
2012
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Métodos de classificação por contagem são mais eficientes em termos de complexidade de tempo de execução que os métodos de classificação por comparação de chave.

Alternativas
Comentários
  • Os métodos por contagem utilizam informação anterior para ordenar. Dessa forma, eles não estão resolvendo exatamente a mesma classe de problemas dos métodos por comparação.
    De qualquer forma, métodos por contagem conseguem ordenar em tempo linear (O(n+k) para o counting sort, geralmente k=n), enquanto métodos por comparação possuem o limite inferior de O(n log n) (maior que linear).
  • Força Guerreiro!!!!!!


ID
802912
Banca
CESPE / CEBRASPE
Órgão
INMETRO
Ano
2010
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Considerando que A seja um algoritmo, {E1, ..., Em} o conjunto de todas as entradas possíveis de A, e ti o número de passos efetuados por A quando a entrada for Ei , assinale a opção correta.

Alternativas

ID
802963
Banca
CESPE / CEBRASPE
Órgão
INMETRO
Ano
2010
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Se f é uma função de complexidade para um algoritmo F, então O(f) é considerada a complexidade assintótica ou o comportamento assintótico do algoritmo F. Assinale a opção que apresenta somente algoritmos que possuem complexidade assintótica quando f(n) = O(n log n).

Alternativas
Comentários
  • Errado o Gab!!!
    O QuickSort, no pior caso, tem complexidade O(n^2).

    Mas o HeapSort e MergeSort possuem as mesmas complexidas em qlq caso: O(n log n)

    Fonte: https://pt.wikipedia.org/wiki/Quicksort

  • A questão é de 2010, provavelmente na época ninguém fez recuso com um bom embasamento, essa é a tabela padrão dos algoritmos e seus piores e melhores casos, está claríssimo que o QUICK SORT não tem em seu pior caso complexidade nlogn, mas sim n2, portanto questão DEVERIA ter sido anulada.

     

    Algoritmo             Melhor caso       Pior caso

    ----------------------------------------------------------------------
    Select Sort            n2                         n2

    ----------------------------------------------------------------------

    Bubble Sort           n2                        n2

    ----------------------------------------------------------------------

    Inserção Direta     n                          n2

    ----------------------------------------------------------------------

    Heap Sort             nlogn                   nlogn

    ----------------------------------------------------------------------
    Merge Sort           nlogn                   nlogn
    ----------------------------------------------------------------------
    Quick Sort            nlogn                    n2
    ----------------------------------------------------------------------
     

  • e-

    algos de array com complexidade O(nlogn)

    mergesort

    timesort

    heapsort

    subesort

    quicksort

  • Assintótico é o tamanho da entrada que tende ao infinito.

    MergeSot (pior e Melhor caso),QuickSort (Médio Caso) e HeapSor tque possuem complexidade  O (n log n)

    Gabarito E


ID
869506
Banca
VUNESP
Órgão
TJ-SP
Ano
2012
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Considerando o conceito de Complexidade de Algoritmos, representado por O(função), assinale a alternativa que apresenta, de forma crescente, as complexidades de algoritmos.

Alternativas
Comentários
  • O (1) : constante – mais rápido, impossível;
    O (log log n) : super-rápido;
    O (log n) : logarítmico – muito bom;
    O (n) : linear – é o melhor que se pode esperar se algo não pode ser determinado sem examinar toda a entrada;
    O (n log n) : limite de muitos problemas práticos, ex.: ordenar uma coleção de números;
    O (n²) : quadrático;
    O (n^k) : polinomial – ok para n pequeno;
    O (k^n), O (n!), O (nn) : exponencial – evite!

    1 <     log n     <     n     < n log n     < n² < n³ < n99 < 2^n < 3^n

    Fonte: http://www.inf.ufrgs.br/~prestes/Courses/Complexity/aula1.pdf

    .

    Resposta: Letra D

    -> O(log2 n); O(n.log2 n); O(n²); O(n³); O(2^n), ou seja, O(log2 n) < O(n.log2 n) < O(n²) < O(n³) < O(2^n)...

     

     

  • Copiei um comentário de um brother aqui do QC

     

    Constante - O (1): É único caso onde as instruções dos algoritmos são executadas num tamanho fixo de vezes. Ex: Algoritmo que identifica se um número é par ou ímpar;
     
    Logaritmo - O(log n)
    : Ocorre tipicamente em algoritmos que dividem problemas em problemas menores. Ex: Algoritmo de busca binária, buscar um elemento em um vetor ordenado;
     
    Linear - O (n): Uma operação básica é executada em cada elemento de entrada do algoritmo. Ex: Busca sequêncial;
     
    O(n log n): Dividem problemas em problemas menores, porém juntando posteriormente a solução dos problemas menores. Ex: Merge Sort;
     
    Quadrática - O(n²): Os itens são processados aos pares, 2 laços aninhados. Ex: Somatório de duas matrizes (2 laços aninhados);
     
    Cúbica - O(n³): Os itens são processados três a três, com 3 laços aninhados. Ex: Multiplicação de matrizes (3 laços aninhados);

     

    Exponencial - O a de n: Algoritmos muitos custosos, possuem pouca aplicação prática. Ex: Algoritmos de força bruta que testam todas as possibilidades;

  • Força Guerreiro!!!!!!


ID
906289
Banca
FCC
Órgão
TRT - 9ª REGIÃO (PR)
Ano
2013
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Analise as afirmativas:

I. Considere o método de ordenação que implementa o seguinte processo: uma coleção desordenada de n elementos é dividida em duas metades e cada metade é utilizada como argumento para a reaplicação recursiva da subrotina. Os resultados das duas reaplicações são, então, combinados pela intercalação dos elementos de ambas, resultando em uma coleção ordenada. A complexidade do caso médio desse algoritmo é expressa por O(n log2 n).

II. Existem aplicações para listas lineares nas quais inserções, retiradas e acessos a itens ocorrem sempre em um dos extremos da lista. Nestes casos a estrutura adequada para resolvê-los é a pilha ou stack.

III. No método Quicksort, o pivô é responsável pelo número de partições em que o vetor é dividido. Como o pivô não pode ser um elemento que esteja repetido no vetor, o Quicksort não funciona quando há elementos repetidos.

Está correto o que se afirma em

Alternativas
Comentários
  • I. Trata-se do método MergeSort, corretamente descrito, cuja complexidade de tempo é Θ(n log2 n). Alternativa VERDADEIRA.

     http://pt.wikipedia.org/wiki/Merge_sort



    II - As duas estruturas de dados lineares que permitem inserções, retiradas e acessos somente aos extremos da lista são pilhas (stacks) e filas (queues). Alternativa VERDADEIRA.

    http://pt.wikipedia.org/wiki/Pilha_(inform%C3%A1tica)



    III - No método QuickSort, qualquer elemento pode ser o pivô. Este obviamente funciona mesmo quando há elementos repetidos. Alternativa FALSA.

    http://pt.wikipedia.org/wiki/Quick_sort

  • Força Guerreiro!!!!!!


ID
1053931
Banca
CESGRANRIO
Órgão
CMB
Ano
2012
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Em uma reunião de análise de desempenho de um sistema WEB, um programador apontou corretamente que a complexidade de tempo do algoritmo bubblesort, no pior caso, é

Alternativas
Comentários
  • O bubblesort ou bolha possui uma baixa performance se comparada a outros algoritmos como o quicksort e o heapsort. No melhor caso, o bubblesort tem O(n). No médio e no pior caso: O(n^2
  • 1 - Bubble = Melhor,Médio,Pior caso = O(N²)

     

    2 - Selection = Melhor,Médio,Pior caso = O(N²)

     

    3 - Insertion = Melhor caso = O(n), Médio,Pior caso =  O(N²)

     

    4 - Merge = Melhor,Médio,Pior caso = O(n log n)

     

    5 - Heap =  Melhor,Médio,Pior caso = O(n log n)

     

    6 - Quick = Melhor, Médio caso O (n log n), Pior caso = O(N²)

     

  • Força Guerreiro!!!!!!


ID
1062631
Banca
CESGRANRIO
Órgão
Petrobras
Ano
2012
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Todos os N nomes de uma lista de assinantes de uma companhia telefônica foram inseridos, em ordem alfabética, em três estruturas de dados: uma árvore binária de busca, uma árvore AVL e uma árvore B.

As alturas resultantes das três árvores são, respectivamente,

Alternativas
Comentários
  • A complexidade da árvore binária de busca  é :  O(N)

     

    A complexidade da árvore AVL é: O(Log(N))

     

    A complexidade da árvore B é: O(Log(N))

  • 1 - Árvore binária de busca (ou árvore binária de pesquisa) é uma estrutura de dados de árvore binária baseada em nós, onde todos os nós da subárvore esquerda possuem um valor numérico inferior ao nó raiz e todos os nós da subárvore direita possuem um valor superior ao nó raiz (esta é a forma padrão, podendo as subárvores serem invertidas, dependendo da aplicação).O objetivo desta árvore é estruturar os dados de forma a permitir busca binária.

    Algortimo      Caso Médio     Pior caso

    Busca              O(log n)             O(n)

    Inserção          O(log n)           O(n)

    Remoção        O(log n)           O(n)

     

    2 - Árvore AVL é uma árvore binária de busca balanceada, ou seja, uma árvore balanceada (árvore completa) são as árvores que minimizam o número de comparações efetuadas no pior caso para uma busca com chaves de probabilidades de ocorrências idênticas. Contudo, para garantir essa propriedade em aplicações dinâmicas, é preciso reconstruir a árvore para seu estado ideal a cada operação sobre seus nós (inclusão ou exclusão), para ser alcançado um custo de algoritmo com o tempo de pesquisa tendendo a O(log N).

     

    Algortimo      Caso Médio     Pior caso

    Busca              O(log n)             O(log n

    Inserção          O(log n)            O(log n

    Remoção        O(log n)            O(log n

     

    3 - Árvore B é uma estrutura de dados projetada para funcionar especialmente em memória secundária como um disco magnético ou outros dispositivos de armazenamento secundário.

    De acordo com a definição de Knuth de ordem e página folha de Bayer e McCreight, uma árvore B de ordem d (número máximo de páginas filhas para uma página pai) deve satisfazer as seguintes propriedades:

     

    1 - Cada página contém no máximo d páginas filhas

    2 - Cada página, exceto a raiz e as folhas, tem pelo menos ⌈d/2⌉ páginas filhas

    3 - A página raiz tem ao menos duas páginas filhas (ao menos que ela seja uma folha)

    4 - Toda página folha possui a mesma profundidade, na qual é equivalente à altura da árvore

    5 - Uma página não folha com k páginas filha contem k-1 chaves

    6 - Uma página folha contém pelo menos ⌈d/2⌉-1 chaves e no máximo d-1 chaves

     

    Algortimo      Caso Médio     Pior caso

    Busca              O(log n)             O(log n

    Inserção          O(log n)            O(log n

    Remoção        O(log n)            O(log n

  • d-

    tabela que tem ter gravada

    https://www.bigocheatsheet.com/

  • Força Guerreiro!!!!!!


ID
1095817
Banca
IDECAN
Órgão
Banestes
Ano
2012
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Sabendo que o algoritmo pode ser considerado como uma sequência de ações executáveis para obtenção de uma solução para um determinado tipo de problema e que pode ser mensurado para se obter um tempo de execução em relação a algumas variáveis, marque os 3 cenários apresentados pelo tempo de execução de um algoritmo.

Alternativas
Comentários
  • Esta questão que não está categorizada corresponde a Algorítimo

  • A questão corresponde a área de Projeto e análise de algoritmos

  • e-

    algo____________best___________average___________worst

    Quicksort  Ω(n log(n))___________  Θ(n log(n))___________  O(n^2)  

    Mergesort  Ω(n log(n)) ___________ Θ(n log(n)) ___________ O(n log(n))  

    Timsort  Ω(n) ___________ Θ(n log(n)) ___________ O(n log(n))  

    Heapsort  Ω(n log(n))___________  Θ(n log(n)) ___________ O(n log(n))

    Bubble Sort  Ω(n) ___________ Θ(n^2) ___________ O(n^2)

    Insertion Sort  Ω(n) ___________ Θ(n^2) ___________ O(n^2)

    Selection Sort  Ω(n^2) ___________ Θ(n^2) ___________ O(n^2)

    Tree Sort  Ω(n log(n)) ___________ Θ(n log(n)) ___________ O(n^2)

    Shell Sort  Ω(n log(n)) ___________ Θ(n(log(n))^2) ___________ O(n(log(n))^2)

    Bucket Sort  Ω(n+k) ___________ Θ(n+k) ___________ O(n^2)

    Radix Sort  Ω(nk) ___________ Θ(nk) ___________ O(nk)

    Counting Sort  Ω(n+k) ___________ Θ(n+k) ___________ O(n+k)

    Cubesort  Ω(n)  ___________Θ(n log(n)) ___________ O(n log(n))  

  • Força Guerreiro!!!!!!


ID
1095952
Banca
CAIP-IMES
Órgão
Câmara Municipal de São Caetano do Sul - SP
Ano
2012
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

A complexidade de execução do algoritmo heapsort, no pior caso é:

Alternativas
Comentários
  • Tem um desempenho em tempo de execução muito bom em conjuntos ordenados aleatoriamente, tem um uso de memória bem comportado e o seu desempenho em pior cenário é praticamente igual ao desempenho em cenário médio. Alguns algoritmos de ordenação rápidos têm desempenhos espectacularmente ruins no pior cenário, quer em tempo de execução, quer no uso da memória. O Heapsort trabalha no lugar e o tempo de execução em pior cenário para ordenar n elementos é de O (n lg n). Lê-se logaritmo (ou log) de "n" na base 2. Para valores de n, razoavelmente grandes, o termo lg n é quase constante, de modo que o tempo de ordenação é quase linear com o número de itens a ordenar.


    http://pt.wikipedia.org/wiki/Heapsort

  • Força Guerreiro!!!!!!


ID
1151056
Banca
FUMARC
Órgão
AL-MG
Ano
2014
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Analise as seguintes afirmativas sobre a análise de complexidade das operações possíveis em estruturas de dados do tipo Pilha:

I. A operação de inserção de um elemento na pilha precisa reorganizar a estrutura de dados, podendo gastar um tempo de execução de O(n).
II. A operação de retirada de um elemento da pilha é uma operação de tempo constante O(1).
III. Na operação de consultar toda a pilha, todos os elementos são percorridos, gastando-se um tempo de execução de O(n).

Estão CORRETAS as afirmativas:

Alternativas
Comentários
  • LETRA C

    Inserção e retirada da pilha serão ambas O(1), já que eu insiro no topo e retiro no topo, não impoortando o número de elementos da pilha. Só é realizada uma operação

  • Ao inserir um elemento em uma pilha não é necessário a reestruturação da mesma.

  • I. A operação de inserção de um elemento na pilha precisa reorganizar a estrutura de dados, podendo gastar um tempo de execução de O(n). 

    ERRADO. Inserir ou retirar elementos da pilha é uma operação simples no topo da pilha, não precisando qualquer leitura nos outros dados. Complexidade O(1).

     


    II. A operação de retirada de um elemento da pilha é uma operação de tempo constante O(1). 

    CORRETO. Como dito anteriormente, tanto a inserção como a remoção de elementos, na pilha, opera apenas no topo da pilha. Complexidade O(1).

     

     


    III. Na operação de consultar toda a pilha, todos os elementos são percorridos, gastando-se um tempo de execução de O(n). 

    CORRETO. A consulta em pilha é sequencial, percorrendo todos os elementos. A complexidade será tão maior quanto maior for a pilha. Complexidade O(n).

     

     

    Sendo assim, itens II e III estão corretos.

    Alternativa C.

  • Força Guerreiro!!!!!!


ID
1160572
Banca
FUMARC
Órgão
AL-MG
Ano
2014
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Analise as seguintes afirmativas sobre a análise de complexidade das operações possíveis em estruturas de dados do tipo Pilha:

I. A operação de inserção de um elemento na pilha precisa reorganizar a estrutura de dados, podendo gastar um tempo de execução de O(n).

II. A operação de retirada de um elemento da pilha é uma operação de tempo constante O(1).

III. Na operação de consultar toda a pilha, todos os elementos são percorridos, gastando-se um tempo de execução de O(n).

Estão CORRETAS as afirmativas:

Alternativas
Comentários
  • I - Errada. A pilha é uma estrutura de dados onde as inserções e remoções são realizadas em apenas um extremo.

  • Força Guerreiro!!!!!!


ID
1208251
Banca
CESPE / CEBRASPE
Órgão
TJ-SE
Ano
2014
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

        Um sistema de controle distribui os processos para os juízes de um tribunal utilizando critérios de prioridade associados a cada processo, de modo que novos processos podem ser analisados pelos juízes enquanto outros aguardam análise.

Considerando essas informações, julgue os itens a seguir, acerca dos tipos básicos de estruturas de dados e de operações sobre estruturas de dados.

Caso a implementação seja realizada por meio de max-heap, a operação de remoção de processos de maior prioridade levará um tempo de ordem O(log n).

Alternativas
Comentários
  • puro chute essa... alguma explicação?

  • O consumo de tempo do algoritmo é proporcionalao número de iterações do bloco de linhas 3 a 9. Para calcular esse número,examine a sequência de valores da variável j. No pior caso, j assume os valores i, 2i, 4i,…, 2ki, … continuando enquanto tivermos 2ki ≤ n. O maior valor de k nessa sequência será lg (n/i). Portanto,o número de iterações será lg (n/i) no pior caso e o consumo total de tempo será Ο(lg(n/i))




    Portanto,o consumo de tempo no pior caso é proporcional à alturado nó i na árvore.Se i = 1, por exemplo, o consumo de tempo é Ο(lg n). Se i = 2, o consumo também é Ο(lg n). Se i é maior que n/2,o consumo também é constante(ou seja, não depende de n nem de i).


    http://www.ime.usp.br/~pf/analise_de_algoritmos/aulas/heap.html

  • Heap é algoritmo de ordenação que imita uma arvora binária em forma de array. Como a busca em uma arvora binária a ordem é logarítmica, no heap tb vai ser.
  • a complexidade do heapsort é igual a do mergesort -> log n em todos os casos 

  • Força Guerreiro!!!!!!


ID
1289161
Banca
CESGRANRIO
Órgão
Petrobras
Ano
2012
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Um vetor ordenado de inteiros com 2N+1 elementos, com N=0, será usado para criar uma árvore binária de busca da seguinte maneira: o elemento central, de índice N, será usado para criar a raiz; depois, serão inseridos na árvore todos os elementos na seguinte ordem de índices: N-1, N+1, N-2, N+2, ..., 1, 2N-1, 0, 2N.

Assumindo que a altura de uma folha é zero, qual será a altura resultante dessa árvore?

Alternativas
Comentários
  • Help!!!

    Não entendi a resposta!

  • No enunciado informou que N= 0 e se uma árvore binária não EXIISTIR folhas, ou seja, não há filhos, ela não existe SOMENTE com a raiz.. Então sua altura é N=0

  • Força Guerreiro!!!!!!


ID
1294081
Banca
CESGRANRIO
Órgão
Petrobras
Ano
2012
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Um programador recebeu a tarefa de elaborar um algoritmo para criar uma única lista encadeada, não necessariamente ordenada, a partir de duas listas encadeadas ordenadas já existentes.

Cada uma das listas originais possui ponteiros para o primeiro e para o último elementos. Qual é a complexidade do algoritmo mais eficiente que esse programador pode produzir?

Alternativas
Comentários
  • Basta apontar o último nó de de uma das listas para o primeiro nó da outra lista.

  • Força Guerreiro!!!!!!


ID
1302043
Banca
FGV
Órgão
SUSAM
Ano
2014
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

 Considere  o  seguinte  pseudocódigo,  no  qual  uma  rotina  com  complexidade O(n) é aplicada em um laço duplo. 


PARA i ←1 ATÉ n FAÇA      
           INÍCIO           
                      PARA j ←1 ATÉ i FAÇA               
                                 INÍCIO 
rotina com complexidade Ο(n);                
                         FIM;           
             FIM PARA;      
      FIM; 
FIM PARA; 


Alternativas
Comentários
  • Qual é a pergunta??

  • Pior banca que eu conheço. Fazem questões que só eles entendem.

  • O que é isso? Que questão horrível!

  • Pelo contesto da questão eles estão querendo saber a complexidade do algoritmo. Para isso é preciso analisar a complexidade de dentro pra fora dos laços:

    Dentro do segundo laço a complexidade é O(n) (a rotina)

    A quantidade de vezes que o segundo laço será executado depende do valor de i, ou seja, em cada iteração do primeiro laço ele será executado:(1 + 2 + 3 + ... + n) vezes. A complexidade fica: O(1) + O(2) + ... + O(n)

    O primeiro laço será executado n vezes, então a complexidade será O(n).

    Juntando todas as complexidades: O(n) x (O(1) + O(2) + ... + O(n)) x O(n), removendo as constantes temos O(n) x O(n) x O(n) = O(n³)

    GABARITO: Letra D
  • La Pregunta? o.O

  • Força Guerreiro!!!!!!


ID
1309774
Banca
CESPE / CEBRASPE
Órgão
ANTAQ
Ano
2014
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

No que diz respeito à engenharia de testes, julgue o item subsecutivo.


A medida de complexidade ciclomática é obtida pela contagem de estruturas de seleção e repetição ou pela contagem do número de regiões do grafo de fluxo, tendo a segunda técnica menor precisão que a primeira.

Alternativas
Comentários
  • Complexidade Ciclomática é computada através do grafo de fluxo de controle do programa: os nós do grafo correspondem a grupos indivisíveis de comandos, e uma aresta direcionada conecta dois nós se o segundo comando pode ser executado imediatamente após o primeiro. A complexidade ciclomática também pode ser aplicada a funções, módulos, métodos ou classes individuais de um programa.

    fonte wikipédia

  • A complexidade ciclomatica é o número de comparações + 1

  • A complexidade ciclomática pode ser medida das duas formas: soma dos nós predicativos (nó que sai duas ou mais arestas - com condição) + 1 ou número de arestas - número de nós + 2. O errado está em dizer que uma é menos precisa do que a outra.

  • http://blog.caelum.com.br/medindo-a-complexidade-do-seu-codigo/

  • Não importa como se obtenha a complexidade ciclomática, o número tem que ser sempre o mesmo.

  • Força Guerreiro!!!!!!


ID
1348765
Banca
CESPE / CEBRASPE
Órgão
INMETRO
Ano
2010
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

No que concerne a complexidade e eficiência de algoritmos, é correto afirmar que

Alternativas
Comentários
  • e - avanços em compiladores e em ferramentas de busca usadas na Internet podem ser produzidos por melhorias em algoritmos.


ID
1470826
Banca
UNIRIO
Órgão
UNIRIO
Ano
2014
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Sobre a análise de algoritmos, é CORRETO afirmar que

Alternativas
Comentários
  • Gabarito B?  Oi? 

    Bubble Sort algoritmo por inserção? É ordenação por troca! 

    Pra mim a única correta é a letra A! Alguém pode ajudar?

  • Amigo Christian, Leia com calma!! Bubble-Sort E o algorítimo por inserção ..... "em média"...fazem sim o mesmo número de comparações...0(n^2).

  • Tabela de complexidade dos algoritmos de ordenação : https://d2m498l008ebpa.cloudfront.net/2016/12/compara--o-entre-os-m-todos-de-ordena--o.png

  • Ambos tem complexidade O(n^2);

  • Gabarito B

    BUBBLE SORT ---> complexidade pior n2.

    INSERÇÃO DIRETA ---> complexidade pior n2 e complexidade melhor n.

     

     

     

    "Retroceder Nunca Render-se Jamais !"
    Força e Fé !
    Fortuna Audaces Sequitur !

  • a) o algoritmo MERGE-SORT é um algoritmo que recebe como entrada duas listas ordenadas e retorna a junção ordenada delas.

    Incorreta, na verdade é UMA LISTA que é dividida em duas listas, NÃO NECESSARIAMENTE ORDENADAS

    b) o BUBBLE-SORT e o algoritmo de ordenação por inserção fazem, em média, o mesmo número de comparações.

    Correta, gabarito da questão, os colegas abaixo já explicaram o motivo!

    .

    c) o algoritmo BUBBLE-SORT é um exemplo de algoritmo de ordenação que utiliza a técnica dividir para conquistar.

    Incorreta, BUBBLE-SORT utilizar a 'técnica' para o topo o maior, quem utiliza a técnica dividir para conquistar são os algoritmos merge-sort e quick-sort.

    .

    d) tanto o algoritmo QUICKSORT quanto o de ordenação por inserção tem complexidade O(n × log n).

    Incorreta, os dois algoritmos possuem distintas complexidades, porém ambos possuem a complexidade O(n²) no pior caso.

    .

    e) o desempenho na execução do algoritmo QUICK-SORT independe da escolha do pivô.

    Incorreta, a escolha do pivô no quick-sort é FUNDAMENTAL para determinar a complexidade do algoritmo

  • Força Guerreiro!!!!!!


ID
1474705
Banca
CESGRANRIO
Órgão
Petrobras
Ano
2010
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Os números 1,2,3,...,N foram inseridos de forma ordenada em uma árvore binária de busca, em uma árvore AVL e em um vetor para o qual foi decidido que a posição do número i seria dada pelo índice i-1. Depois, sabendo-se que nenhuma inserção posterior será realizada em nenhuma das três estruturas, decidiu-se fazer uma busca em cada uma destas. Os tempos que se podem obter para essa busca na árvore binária de busca, na árvore AVL e no vetor são, respectivamente,

Alternativas
Comentários
  • Busca Binária Ordenada: O(N)

    Busca AVL: O(Log N)

    Vetor pelo índice i-1: O(1) 

     

    A pegadinha estava na busca pelo índice. Do contrário, seria busca sequencia, de complexidade O(N)


ID
1474780
Banca
CESGRANRIO
Órgão
Petrobras
Ano
2010
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

O algoritmo de ordenação de pior complexidade temporal no caso médio, dentre os que se seguem, é

Alternativas
Comentários
  • Gabarito B

    BubbleSort - pouco eficiente para ordenar grandes quantidades de informações. Compara posições adjacentes e vai ordenando o vetor. Elemento da posição i é comparado com o elemento da posição i + 1. 
     

     

     

     

    "Retroceder Nunca Render-se Jamais !"
    Força e Fé !
    Fortuna Audaces Sequitur !

  • algo____________best___________average___________worst

    Quicksort  Ω(n log(n))___________  Θ(n log(n))___________  O(n^2)  

    Mergesort  Ω(n log(n)) ___________ Θ(n log(n)) ___________ O(n log(n))  

    Timsort  Ω(n) ___________ Θ(n log(n)) ___________ O(n log(n))  

    Heapsort  Ω(n log(n))___________  Θ(n log(n)) ___________ O(n log(n))

    Bubble Sort  Ω(n) ___________ Θ(n^2) ___________ O(n^2)

    Insertion Sort  Ω(n) ___________ Θ(n^2) ___________ O(n^2)

    Selection Sort  Ω(n^2) ___________ Θ(n^2) ___________ O(n^2)

    Tree Sort  Ω(n log(n)) ___________ Θ(n log(n)) ___________ O(n^2)

    Shell Sort  Ω(n log(n)) ___________ Θ(n(log(n))^2) ___________ O(n(log(n))^2)

    Bucket Sort  Ω(n+k) ___________ Θ(n+k) ___________ O(n^2)

    Radix Sort  Ω(nk) ___________ Θ(nk) ___________ O(nk)

    Counting Sort  Ω(n+k) ___________ Θ(n+k) ___________ O(n+k)

    Cubesort  Ω(n)  ___________Θ(n log(n)) ___________ O(n log(n))  


ID
1477552
Banca
CONSULPLAN
Órgão
TRE-MG
Ano
2015
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

A pesquisa de dados envolve a determinação da chave pesquisada estar ou não entre os dados pesquisados e, caso  esteja, que seja encontrada sua localização. Em computação, a pesquisa tem um papel importante, pois de posse do  campo chave a ser pesquisado fica mais fácil encontrar determinado arquivo, ou mesmo qualquer item que se queira  buscar.  Já  a  classificação  envolve  a  organização  dos  dados  em  uma  determinada  ordem,  por  exemplo:  crescente,  decrescente, ordem alfabética, numérica, entre outros. Acerca dos algoritmos de pesquisa e classificação, analise as  afirmativas a seguir.

I. Diz-se que o algoritmo 0(log n) tem um tempo de execução linear.
II. A pesquisa binária executa em 0(log n) vezes, pois cada passo remove metade dos elementos restantes. 
III. O algoritmo de classificação por inserção executa no tempo 0(n²), no pior caso e no caso médio. 
IV.No pior caso, a primeira chamada à classificação por intercalação tem de fazer 0(n) comparações para preencher os n slots no array final. 

Estão corretas apenas as afirmativas 

Alternativas
Comentários
  • Pra mim, o gabarito deveria ser B.

    IV- classificação por intercalação é o mesmo que MergeSort. Logo deveria ser O(nlogn) para preencher os slots do array final.

    Alguém comenta?

  • Letra Correta B)

    Algoritmos por inserção é somente o "Insertion Sort" que possui complexidade 

    Melhor Caso O(n) 

    Caso Médio O(n²) 

    Pior Caso O(n²)

  • Também acredito, quanto ao III não tenho dúvidas.

     

    Quanto ao IV acredito que ele se refira a primeira chamada à classificação por intercalação, ou seja o passo de combinar.

     

    O algoritmo tem duas fases. Primeiro se quebra o array recursivamente em n arrays de um elemento,

     

    Depois começa-se a intercalação em um laço recursivo. Cada um desses laços vai fazer n comparações e como a cada passo teremos arrays com o dobro de tamanho, ordenada, esse laço precisará ser executado executado log2(n) vezes. Daí a complexidade n*log2(n).

     

    Foi isso que tinha entendido, embora falta clareza ao item.

     

    https://upload.wikimedia.org/wikipedia/commons/c/cc/Merge-sort-example-300px.gif

     

     

  • Tempo logarítmico O(log n) Busca binária

    Tempo linear O(n)  Procurando o menor item em um array não ordenado

    Tempo quadrático O(n2)  Bubble sort; Insertion sort

    Insertion sort algoritmo de classificação por inserção:

                                                                            complexidade pior caso O(n2)

                                                                            complexidade caso médio O(n2)

                                                                            complexidade melhor caso O(n)

     

     

     

     

  • Resposta da banca ao recurso:

    Recurso Improcedente. Ratifica-se a opção divulgada no gabarito preliminar. A banca mantém o gabarito divulgado anteriormente. (Gab. C)

    I) Diz-se que o algoritmo 0(n) tem um tempo de execução linear.

    III) O algoritmo de classificação por seleção executa no tempo 0(n²).

    Fonte: DEITEL, P.; DEITEL, H. – Java: como programar – 8ª ed. São Paulo: Person Prentice Hall, 2010 – pág.: 633.

    Gab. Final: C

    Banca doida... =P

  • Força Guerreiro!!!!!!


ID
1530406
Banca
FGV
Órgão
SUSAM
Ano
2014
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Considere o seguinte pseudocódigo, no qual uma rotina com complexidade O(n) é aplicada em um laço duplo.

                              PARA i ←1 ATÉ n FAÇA
                                          INÍCIO
                                                    PARA j ←1 ATÉ i FAÇA
                                                               INÍCIO
                              rotina com complexidade O(n);
                                                       FIM;
                                            FIM PARA;
                                     FIM;
                         FIM PARA;

Alternativas
Comentários
  • PARA + PARA + Rotina = 3

    Logo, n³

  • Força Guerreiro!!!!!!

  • Força Guerreiro!!!!!!

  • Fala concurseiro, professor Martins na área...

    Para calcular a complexidade de questões como essa, basta seguir esses três passos:

    1. Considerar apenas as repetições do código

    2. Verificar a complexidade das funções / métodos

    3. Ignorar as constantes e utilizar o termo de maior grau

    Vejamos:

    PARA i ←1 ATÉ n FAÇA -------------> O(n)

                                              INÍCIO

                                                        PARA j ←1 ATÉ i FAÇA -------------> O(n)

                                                                   INÍCIO

                                  rotina com complexidade O(n); -------------> O(n)

                                                           FIM;

                                                FIM PARA;

                                         FIM;

                             FIM PARA;

    Identificamos que as repetições são de complexidade O(n), como são iguais e estão dentro uma da outra, então basta multiplicar os valores:

    O(n)*O(n)*O(n) = O(n^3)

    Vamos juntos ser aprovados, guerreiro(a)!

    Para mais dicas me segue no insta @profmartinz


ID
1688638
Banca
UFRRJ
Órgão
UFRRJ
Ano
2015
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Em seu pior caso, o tempo de ordenação do algoritmo Quicksort sobre um arranjo de n números é igual a

Alternativas
Comentários
  • O pior caso de particionamento ocorre quando o elemento pivô divide a lista de forma desbalanceada, ou seja, divide a lista em duas sublistas: uma com tamanho 0 e outra com tamanho n - 1 (no qual n se refere ao tamanho da lista original). Isso pode ocorrer quando o elemento pivô é o maior ou menor elemento da lista, ou seja, quando a lista já está ordenada, ou inversamente ordenada.

    (...)

    o algoritmo terá tempo de execução igual à θ(n²).

     

     

    https://pt.wikipedia.org/wiki/Quicksort

  • tem que decorar amiguinhos

     

     

    2017

    O algoritmo QuickSort usa uma técnica conhecida por divisão e conquista, onde problemas complexos são reduzidos em problemas menores para se tentar chegar a uma solução. A complexidade média deste algoritmo em sua implementação padrão e a complexidade de pior caso são, respectivamente,

     a) O(n-1) e Ο(n³).

     b) Ο(n²) e Ο(n log n²).

     c) O(n²) e O(n³).

     d) Ο(n) e Ο(n²).

     e) Ο(n log n) e Ο(n²).

     

  • Gabarito A

    QUICK SORT ---> complexidade no pior caso n2 e complexidade no melhor caso nlogn.
     

    Vamos na fé !

     

     

     

    "Retroceder Nunca Render-se Jamais !"
    Força e Fé !
    Fortuna Audaces Sequitur !

  • a-

    Quicksort - Neste método, a lista é dividida em parte esquerda e parte direita, sendo que os elementos da parte esquerda são todos menores do que os elementos da parte direita. Em seguida, as duas partes são ordenadas recursivamente.

  • Força Guerreiro!!!!!!


ID
1891891
Banca
IF-SC
Órgão
IF-SC
Ano
2014
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

A análise de complexidade de algoritmos é importante para o projeto de algoritmos eficientes desde sua concepção. Assinale a alternativa CORRETA.

Alternativas
Comentários
  • Força Guerreiro!!!!!!


ID
2194567
Banca
INSTITUTO AOCP
Órgão
CASAN
Ano
2016
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Um algoritmo de complexidade exponencial pode ser representado por qual notação?

Alternativas
Comentários
  • Letra A

    Fonte: 

    http://www.ebah.com.br/content/ABAAAAygYAA/algoritimos

  • Letra A

    Fonte:

    https://pt.wikipedia.org/wiki/Complexidade_exponencial



  • Força Guerreiro!!!!!!

  • Fala concurseiro, professor Martins na área...

    Memoriza essa sequência que é só sucesso nas provas:

    O(1) -> Constante

    O(log n) -> Logarítmica

    O[(log n]^c] -> Polilogarítmica

    O(n) -> Linear

    O(n^2) -> Quadrática

    O(n^3) -> Cúbica

    O(n^c) -> Polinomial

    O(c^n)-> Exponencial

    O(n!) -> Fatorial

    Agora é só olhar o comportamento das respostas...

    Alternativa correta: LETRA A

    Vamos juntos ser aprovados, guerreiro(a)!

    Para mais dicas me segue no insta @profmartinz


ID
2200480
Banca
FCM
Órgão
IF Farroupilha - RS
Ano
2016
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

A preocupação com a complexidade de algoritmos é de extrema importância para o projeto de algoritmos eficientes. Neste contexto, a complexidade de tempo no pior caso para o algoritmo de ordenação QuickSort é

Alternativas
Comentários
  • Gabarito: A.

     

    Algoritmo - Melhor / Médio / Pior

     

    Insertion - n [melhor] / n^2 [médio e pior]

    Selection - n^2

    Bubble - n [melhor] / n^2 [médio e pior]

    Quick - n log n [melhor e médio] / n^2 [pior]

    Merge - n log n

  • Esta situação ocorre quando o vetor de entrada já está ordenado. Assim o pivô deverá ser uma das extremidades, sendo que um lado terá 0 elementos, ao passo que a outra parte terá N-1 elementos. Isso faz com que o algoritmo perca seu grande trunfo de dividir para conquistar (n Log n)

  • Força Guerreiro!!!!!!


ID
2241517
Banca
COPESE - UFPI
Órgão
UFPI
Ano
2014
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

No pior caso, uma busca sem sucesso em uma árvore binária perfeita deve visitar uma quantidade de nós internos da ordem de

Alternativas
Comentários
  • Constante - O (1): É único caso onde as instruções dos algoritmos são executadas num tamanho fixo de vezes. Ex: Algoritmo que identifica se um número é par ou ímpar;

     

    Logaritmo - O(log n) : Ocorre tipicamente em algoritmos que dividem problemas em problemas menores. Ex: Algoritmo de busca binária, buscar um elemento em um vetor ordenado;

     

    Linear - O (n): Uma operação básica é executada em cada elemento de entrada do algoritmo. Ex: Busca sequêncial;

     

    O(n log n): Dividem problemas em problemas menores, porém juntando posteriormente a solução dos problemas menores. Ex: Merge Sort;

     

    Quadrática - O(n²): Os itens são processados aos pares, 2 laços aninhados. Ex: Somatório de duas matrizes (2 laços aninhados);

     

    Cúbica - O(n³): Os itens são processados três a três, com 3 laços aninhados. Ex: Multiplicação de matrizes (3 laços aninhados);

     

    Exponencial - O a de n: Algoritmos muitos custosos, possuem pouca aplicação prática. Ex: Algoritmos de força bruta que testam todas as possibilidades;

     

    Fonte: Minhas anotações baseadas nas Apostilas do Estratégia Concurso.

  • 1- f(n) = O(1) – Complexidade constante

    2- f(n) = O(log n) – Complexidade sub-linear ou logarítmica

    3- f(n) = O(n) – Complexidade linear

    4 - f(n) = O(n log n) – Sub-divisão de problema (Exe.: MergeSort e QuikSort)

    5 - f(n) = O(n^2) – Complexidade polinomial

    6 - f(n) = O(2^n) – Complexidade exponencial

    7 - f(n) = O(n!) – Complexidade fatorial

  • Força Guerreiro!!!!!!


ID
2246998
Banca
Marinha
Órgão
Quadro Técnico
Ano
2016
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

O algoritmo a seguir apresenta uma operação com pilhas.

ocupar (pt);
pt —> info := novo_valor;
pt —> prox := topo;
topo := pt;

Sobre o algoritmo acima é correto afirmar que se refere ao

Alternativas
Comentários
  • Considerando-se listas simplesmente encadeadas, o topo da pilha é o primeiro nó da lista, apontado por uma variável ponteiro topo.

    Algoritmo de Inserção na Pilha

    Ocupar (pt);
    pt^.info := novo_valor;
    pt^.prox := topo;
    topo := pt;

    Algoritmo de Remoção da Pilha

    se topo != nil então
    pt := topo;
    topo := topo^.prox;
    valor_lido := pt^.info;
    desocupar (pt);
    senão underflow;

  • B

    procedimento de inserção em pilha, no qual o novo nó será considerado o topo da pilha.


ID
2286736
Banca
SUGEP - UFRPE
Órgão
UFRPE
Ano
2016
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

A Complexidade Computacional é a área da Ciência da Computação que se ocupa, entre outros, do estudo e análise do custo de tempo de execução e espaço ocupado pelos algoritmos. Sobre Complexidade Computacional, marque V para as afirmações Verdadeiras, ou F para as Falsas.
( ) A função de complexidade de tempo de algoritmo indica o tempo necessário para executar o programa que implementa o algoritmo em função do tamanho da entrada.
( ) Se f é uma função de complexidade baseada na análise de pior caso, o custo de aplicar o algoritmo nunca é maior do que f(n).
( ) Na análise do caso médio toma-se a média aritmética do pior caso com o melhor caso.
A sequência correta, de cima para baixo, é:

Alternativas
Comentários
  • Questão estranha.. não consegui encontrar resposta para as alternativas I e II.

    I - A função de complexidade de tempo de algoritmo indica o tempo necessário para executar o programa que implementa o algoritmo em função do tamanho da entrada.

    Definição do Wikipedia: "Em ciência da computação, a complexidade de tempo de um algoritmo quantifica a porção de tempo tomada por um algoritmo para rodar em função do tamanho da entrada do problema". Não encontrei diferença que justifique a alternativa ser Falsa.

     

    II Se f é uma função de complexidade baseada na análise de pior caso, o custo de aplicar o algoritmo nunca é maior do que f(n).

    Para este exemplo, o Quicksort em seu pior caso é de complexidade O(n²), portanto maior que O(n).

     

    Se alguém puder explicá-la, agradeceria.

  • Oi Leonardo, o caso II creio que ele esteja falando que a função f(n) é o pior caso. Por ser o pior caso, nada virá acima dela com relação à complexidade do algoritmo. Foi assim que entendi pelo menos! A meu ver ele não está dizendo que f(n) é O(n).

     

     

  • Verdade Yane Wanderley, consegui compreender!

    Obrigado pela explicação!

  • Leonardo, com relação à II, quando ele diz f(n) ele não está se referindo à complexidade linear O(n). f(n) é a função de complexidade de tempo do algoritmo. De fato ela nunca será maior que o pior caso do algoritmo. Portanto, II está correta.

  • Creio que o erro da I está em afirmar que a função de complexidade indica o tempo necessário para executar o programa, o que não é necessariamente verdade. Por exemplo, podemos ter uma função de tempo em que o programa é executado em 5n³ + 2n² + 500n unidades de tempo, porém sua função de complexidade será apenas O(n³).

  • Força Guerreiro!!!!!!


ID
2324848
Banca
IFB
Órgão
IFB
Ano
2017
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Na análise de algoritmos para resolver certos problemas, é necessário avaliar não só o tamanho dos dados de entrada, mas os diferentes cenários para esses dados de entrada. Estes cenários são:

Alternativas
Comentários
  • Na ciência da computação, melhor casopior caso, e o caso médio de um determinado algoritmo, expressa a quantidade de recurso usado nesse algoritmo, no mínimono máximo e em média, respectivamente. Normalmente, o recurso a ser considerado é o tempo de execução, isto é, complexidade do tempo, porém poderia ser também a quantidade de memória usada ou outros recursos.

     

    https://pt.wikipedia.org/wiki/Melhor_caso,_pior_caso_e_caso_m%C3%A9dio

  • Força Guerreiro!!!!!!


ID
2324851
Banca
IFB
Órgão
IFB
Ano
2017
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Considere a função de complexidade f(n) = 3n3 + 4n2 +2n. Selecione a opção abaixo contendo o menor valor para a constante c, c>0, para que g(n) = c.n3 domine assintoticamente f(n), para n>= 1.

Alternativas
Comentários
  • não sei se esta certo mas apenas somei as quantidades de n por exemplo f(n)=3n^3 + 4n^2+2n

    cortei os numeros e somei os expoentes 3+2+1 

     

    e depois somei com g(n)=c.n^3 que seria 6+3 =9

     

    nao sei se foi cagada mas acertei rs

  • Acredito que seja feito dessa forma:

    3n3 + 4n2 +2n = c.n3

    Para que o c recebe o menor valor possível com n>=1. Então, n deve ser 1.

    3(1)3 + 4(1)2 +2(1) = c.(1)3

    Logo, c=9.

  • EWelton Yoshidome, não entendi como vc chegou ao 9.

  • A partir do n0 = 9 o g(n) começa a dominar o f(n), pois a partir do 9 qualquer constante que for colocada o g(n) sempre será maior

  • Força Guerreiro!!!!!!


ID
2324854
Banca
IFB
Órgão
IFB
Ano
2017
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Leia as afirmativas a seguir considerando que f(n) e g(n) são funções positivas.
I) Se g(n) é O(f(n)), um algoritmo de função de complexidade de tempo f(n) possui Ordem de complexidade g(n).
II) Se g(n) é O(f(n)), f(n) é um limite superior para g(n).
III) Se a função g(n) = 7.log(n) +6 , então a função g(n) é O(log(n)).
IV) Se g(n) = n2 e f(n) = (n+1)2 temos que g(n) é O(f(n)) e f(n) é O(g(n)).
V) Se g(n) = 2n+1 e f(n) = 2n temos que g(n) = O(f(n)).
Assinale a alternativa que apresenta somente as afirmativas CORRETAS.

Alternativas
Comentários
  • Definição: Dadas funções assintoticamente não negativas f e g, dizemos que f está na ordem Ο de g  e escrevemos  f = Ο(g)   se   f(n)    c · g(n)   para algum c positivo e para todo n suficientemente grande.  Em outras palavras, existe um número positivo c e um número n0 tais que f(n) ≤ c · g(n) para todo n maior que n0.

    I) Se g(n) é O(f(n)), um algoritmo de função de complexidade de tempo g(n) possui Ordem de complexidade f(n). ERRADO

    II) Se g(n) é O(f(n)), f(n) é um limite superior para g(n). CORRETO

    III) Se a função g(n) = 7.log(n) +6 , então a função g(n) é O(log(n)). CORRETO: g(n) ≤ 13 · log(n)

    IV) Se g(n) = nˆ2 e f(n) = (n+1)ˆ2 temos que g(n) é O(f(n)) e f(n) é O(g(n)). CORRETO, mesma complexidade

    V) Se g(n) = 2ˆ(n+1) e f(n) = 2ˆn temos que g(n) = O(f(n)). CORRETO g(n) ≤ 2 · f(n)

  • Força Guerreiro!!!!!!


ID
2324857
Banca
IFB
Órgão
IFB
Ano
2017
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Leia as afirmativas a seguir a respeito das principais classes de comportamento assintótico.
I) A complexidade logarítmica é típica de algoritmos que resolvem problemas, transformando-os em problemas menores e depois agrupando as soluções dos problemas menores.
II) A complexidade quadrática é típica de algoritmos onde os dados são processados ao pares muitas vezes com um anel dentro de outro.
III) Um algoritmo com complexidade exponencial é mais rápido que um algoritmo linear.
IV) Um algoritmo com complexidade n! (n fatorial) apresenta um comportamento pior que um algoritmo com complexidade 2n .
V) A complexidade do algoritmo de pesquisa binária é logarítmica.
Assinale a alternativa que apresenta somente as afirmativas CORRETAS.

Alternativas
Comentários
  • Na I é dsscrita a complexidade N logN, não logN, que ocorre em programas que resolvem um problema maior transformado-o em uma série de subproblemas menores, assim reduzindo o tamanho do problema por uma certa constante fracionária a cada passo.

  • I) A complexidade logarítmica linear é típica de algoritmos que resolvem problemas, transformando-os em problemas menores e depois agrupando as soluções dos problemas menores.

    logarítmica linear = O(n Log n)

  • Força Guerreiro!!!!!!


ID
2476567
Banca
COPEVE-UFAL
Órgão
MPE-AL
Ano
2012
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Desempenho é a grande vantagem da tabela na utilização hash. O tempo de busca na tabela hash tem complexidade O(1), se desconsiderarmos as colisões; entretanto, se as colisões são tratadas usando uma lista encadeada, qual é o tempo de busca máximo para uma tabela hash com n colisões?

Alternativas
Comentários
  • Resumidamente a questão pergunta qual a complexidade no pior caso para uma lista/vetor.

    Resposta: Linearmente O(n)

  • Algoritmos de estrutura linear geralmente utilizam tabelas. (Um macete pra decorar)

  • Força Guerreiro!!!!!!


ID
2482060
Banca
FGV
Órgão
IBGE
Ano
2017
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Para projetar algoritmos eficientes um desenvolvedor deve estar preocupado com a complexidade deste algoritmo, desde sua concepção.

Considere a seguinte função T(n) que mede os recursos (ex. tempo de execução) que um algoritmo necessita no pior caso para processar uma entrada qualquer de tamanho n:

T(n) = O(log(n))


Sabendo que O(log(n)) é a ordem da complexidade de tempo do algoritmo seguindo a notação "big O", é correto afirmar que este algoritmo tem complexidade de ordem: 

Alternativas
Comentários
  • Pensei que seria logarítmica.

  • 1- f(n) = O(1) – Complexidade constante

    2- f(n) = O(log n) – Complexidade sub-linear ou logarítmica

    3- f(n) = O(n) – Complexidade linear

    4 - f(n) = O(n log n) – Sub-divisão de problema (Exe.: MergeSort e QuikSort)

    5 - f(n) = O(n^2) – Complexidade polinomial

    6 - f(n) = O(2^n) – Complexidade exponencial

    7 - f(n) = O(n!) – Complexidade fatorial

     

    Fonte: http://www.ebah.com.br/content/ABAAAAygYAA/algoritimos

  • Prezados,

    Temos a seguinte relação de funções com taxas de crescimento :

    -Tempo constante: O(1) (raro)
    -Tempo sublinear (log(n)): muito rápido (ótimo)
    -Tempo linear: (O(n)): muito rápido (ótimo)
    -Tempo nlogn: Comum em algoritmos de divisão e conquista.
    -Tempo polinomial n^k : Freqüentemente de baixa ordem (k ≤ 10), considerado eficiente.
    • Tempo exponencial: 2n, n!, n^n considerados intratáveis 

    Portanto a alternativa correta é a letra B

  • Força Guerreiro!!!!!!


ID
2492155
Banca
COPESE - UFPI
Órgão
UFPI
Ano
2017
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

A ideia da ordenação por bolha (Bubble Sort) é percorrer o vetor de elementos sequencialmente e, em cada passagem comparar cada elemento com seu sucessor, fazendo-o chegar ao topo da sequência. Dado que n é o número de elementos do vetor, a complexidade do pior caso desse algoritmo é

Alternativas
Comentários
  • Gabarito: B

     

    Algoritmo - Melhor / Médio / Pior (caso)

     

    Insertion - n [melhor] / n^2 [médio e pior]

    Selection - n^2

    Bubble - n [melhor] / n^2 [médio e pior]

    Quick - n log n [melhor e médio] / n^2 [pior]

    Merge - n log n

  • Bubble Sort

    Se arrasta por todo array comparando com os elementos adjacentes ou X e X+1.

    Como Vantagens podemos mencionar que são algoritmos simples e arquivos pequenos.

    Como desvantagens podemos mencionar é necessário percorrer o algoritmo várias vezes e é pouco eficiente.

    Com relação a sua complexidade temos que:

    Pior condição: On²

    Condição média: On²

    Melhor condição: On

  • Força Guerreiro!!!!!!


ID
2524432
Banca
FCC
Órgão
DPE-RS
Ano
2017
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Um Analista, estudando a complexidade de algoritmos de busca linear (ou sequencial), concluiu corretamente que no pior caso, considerando um vetor de n elementos, este tipo de algoritmo tem complexidade

Alternativas
Comentários
  • O gabarito é a letra A. 

     

    A complexidade do algoritmo de busca linear é da ordem de Θ(n), em que n é o tamanho do vetor de busca. 

  • A ideia aqui é a busca retornar n comparações sem sucesso para informar que o registro não foi encontrado. Esta é a ideia de pior caso para a complexidade de busca linear.

  • Busca sequencial : : definição ==> percorre todos os elementos até encontrar, todos os n elementos, entao ordem Θ(n), letra A

  • Complexidade da busca binária: O(log N)

    Complexidade da busca sequencial: O(N)

  • Força Guerreiro!!!!!!


ID
2548774
Banca
FUNCERN
Órgão
IF-RN
Ano
2017
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Considerando a área de complexidade algoritmos, assinale a opção que apresenta a classe assintótica, na notação O, com o menor tempo de resposta dada a mesma entrada de dados n.

Alternativas
Comentários
  • Segue abaixo a ordem:

     

    1     <   log (n)     <    O (n)  <    O (nlogn)         <                O(n2) <  O(n3)   <  O(n99)           <                         O(2n) <  O(3n)

     

     

     

    d) O(log(n))

    Logarítmica

     

     

     

     

     

    Fonte:

    http://uploaddeimagens.com.br/imagens/complexidade_algoritmo-png

  • https://thepracticaldev.s3.amazonaws.com/i/3ms2d5rfv25a2swyz1vs.png

  • Força Guerreiro!!!!!!


ID
2568199
Banca
FCC
Órgão
TRF - 5ª REGIÃO
Ano
2017
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

O algoritmo QuickSort usa uma técnica conhecida por divisão e conquista, onde problemas complexos são reduzidos em problemas menores para se tentar chegar a uma solução. A complexidade média deste algoritmo em sua implementação padrão e a complexidade de pior caso são, respectivamente,

Alternativas
Comentários
  • lamento ser o informante do CAOS

     

    mas puta que pariu

     

    vai ter que decorar a complexidade no caso otimo, medio e ruim para todos os algoritmos

     

     

    2013

    Entre os algoritmos de ordenação e pesquisa bubble sort, quicksort e heapsort, o quicksort é considerado o mais eficiente, pois se caracteriza como um algoritmo de dividir- para- conquistar, utilizando operações de particionamento.

    Errada → HEAPSort

     

  • Mr. Robot ... vai ter que decorar sim.

  • complexidade pior caso O(n²)
    complexidade caso médio O(n * log n)
    complexidade melhor caso O(n * log n)

  • Tabelinha sucesso :

     

    https://d2m498l008ebpa.cloudfront.net/2016/12/compara--o-entre-os-m-todos-de-ordena--o.png

  • Tá de brincadeira...

  • Força Guerreiro!!!!!!


ID
2568217
Banca
FCC
Órgão
TRF - 5ª REGIÃO
Ano
2017
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Considere o algoritmo abaixo.

static int fibonacci(int n) { 

   if (n <= 1) { 

      return n; 

   } 

   return fibonacci(n - 2) + fibonacci(n - 1);  

}

A complexidade deste algoritmo, na notação Big O, é  


Alternativas
Comentários
  • Normalmente chamadas recursivas têm complexidade O(n).

    A diferença deste algorítmo é que a n, são chamadas 2 recursões, daí a resposta ser O(2ⁿ).

  • Força Guerreiro!!!!!!


ID
2639767
Banca
IADES
Órgão
CFM
Ano
2018
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Quando dois elementos estão fora de ordem, há uma inversão, e esses dois elementos são trocados de posição, ficando em ordem correta. Assim, o primeiro elemento é comparado com o segundo. Se uma inversão for encontrada, a troca é feita. Em seguida, independentemente de se houve ou não troca após a primeira comparação, o segundo elemento é comparado com o terceiro, e, caso uma inversão seja encontrada, a troca é feita. O processo continua até que o penúltimo elemento seja comparado com o último. Com esse processo, garante-se que o elemento de maior valor do vetor seja levado para a última posição. A ordenação continua com o posicionamento do segundo maior elemento, do terceiro etc., até que todo o vetor esteja ordenado.

 CELES, W.; CERQUEIRA, R.; RANGEL, J. L. Introdução a Estruturas de Dados. Rio de Janeiro: Elsevier, 2004, com adaptações.


Em relação ao algoritmo descrito, é correto afirmar que a respectiva ordem de complexidade, no pior caso, é

Alternativas
Comentários
  • A questão trata-se do método Bolha “bubble sort”

    E ordem de complexidade, no pior caso, é O(n²)

     

    Fonte: Citada no enunciado da questão

     

     

  • Complementando à nivel de curiosidade:

    Melhor caso: O(n)

    Médio caso:O(n²)

    Pior caso:O(n²)

  • Porque não O(n^n)? Se analisarmos matematicamente apresenta um grau de complexidade maior.

  • Força Guerreiro!!!!!!


ID
2670202
Banca
CESGRANRIO
Órgão
Banco da Amazônia
Ano
2018
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Em uma árvore AVL com grande quantidade de nós, o custo para inclusão de um nó no meio da árvore é proporcional a

Alternativas
Comentários
  • A vantagem do balanceamento é possibilitar que a busca seja de complexidade O (log n). Entretanto, as operações de inserção e remoção devem possuir custo similar. No caso da árvore AVL, a inserção e remoção têm custo O (log n).

    Fonte: https://pt.wikipedia.org/wiki/%C3%81rvore_AVL

  • Força Guerreiro!!!!!!


ID
2670244
Banca
CESGRANRIO
Órgão
Banco da Amazônia
Ano
2018
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Uma árvore binária completa de busca, isto é, uma árvore em que todos os níveis têm o máximo número de elementos, tem um total de N nós.


O número máximo de comparações necessárias para encontrar um elemento nessa árvore é

Alternativas
Comentários
  • Complexidade de Árvores de busca é da ordem de (Log N).

    Algoritmos de complexidade O(log n) são chamados de complexidade logarítmica e resolvem um problema quebrando-o em problemas menores.

    LETRA C

  • Força Guerreiro!!!!!!

  • Uma árvore binária completa possui, em cada nível, o dobro de nós do nível anterior. Isto é, ela segue uma progressão geométrica começando do primeiro nó raiz: 1, 2, 4, 8, ...

    É fácil observar que a quantidade total de nós (N) de uma árvore desse tipo com n níveis é a soma da P.G. finita:

    N = 2- 1

    Dessa forma, para encontrar um nó qualquer, seguindo a lógica de uma árvore de busca, basta saber em qual nível ele está. Assim, obteremos a quantidade de comparações pedida na questão isolando n da fórmula anterior .

    N = 2- 1

    N+1 = 2

    log₂(N+1) = n

    Resposta: C)


ID
2707252
Banca
FUMARC
Órgão
COPASA
Ano
2018
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Analise as afirmativas a seguir sobre complexidade de algoritmos:


I. Algoritmos de complexidade O(n log n) resolvem um problema quebrando-o em problemas menores, resolvendo cada um deles independentemente e depois ajuntando as soluções.

II. Algoritmos de complexidade O(1) são chamados de complexidade linear, onde um pequeno trabalho é realizado sobre cada elemento de entrada.

III. Algoritmos de complexidade O(n) são chamados de complexidade constante, onde o tempo de execução cresce na mesma proporção do crescimento da estrutura de dados.


Estão CORRETAS as afirmativas:

Alternativas
Comentários
  • As complexidades das alternativas II e III foram trocadas:

    I. Algoritmos de complexidade O(n log n) resolvem um problema quebrando-o em problemas menores, resolvendo cada um deles independentemente e depois ajuntando as soluções.

    II. Algoritmos de complexidade O(1) O(n) são chamados de complexidade linear, onde um pequeno trabalho é realizado sobre cada elemento de entrada.

    III. Algoritmos de complexidade O(n)  O(1)são chamados de complexidade constante, onde o tempo de execução cresce na mesma proporção do crescimento da estrutura de dados.

     

    GABARITO LETRA A;

     

    Fundamentação teórica do tema: http://www.decom.ufop.br/toffolo/site_media/uploads/2013-1/bcc202/slides/06._analise_de_algoritmos_(parte_3).pdf

  • Força Guerreiro!!!!!!


ID
2716591
Banca
FUMARC
Órgão
COPASA
Ano
2018
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Analise as afirmativas a seguir sobre complexidade de algoritmos:


I. Algoritmos de complexidade O(log n) são chamados de complexidade logarítmica e resolvem um problema quebrando-o em problemas menores.

II. Algoritmos de complexidade O(n) são chamados de complexidade linear, em que um pequeno trabalho é realizado sobre cada elemento de entrada.

III. Algoritmos de complexidade O(1) são chamados de complexidade constante, em que as instruções do algoritmo são executadas um número fixo de vezes.


Estão CORRETAS as afirmativas:

Alternativas
Comentários
  • 1 -  Constante

    log n -  logaritmica

    log^2 n -  log-quadratica

    n -  linear

    n log n - n log n

    n^2 - quadrática

    n^3 - cúbica

    2^n - exponencial

     

     

    GABARITO - ITEM C

     

  • Força Guerreiro!!!!!!


ID
2743177
Banca
FGV
Órgão
MPE-AL
Ano
2018
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

A complexidade do algoritmo de busca binária, sobre uma lista indexada ordenada pela chave de busca, é

Alternativas
Comentários
  • Gabarito B

    Custo para inserção e remoção de um item
    ▸ A inserção ocorre sempre em uma folha
    ▸ Deve-se percorrer portanto a altura h da árvore
    ▸ Como a árvore pode estar degenerada, no pior caso, a inserção é O(n)
    ▸ No melhor caso O(log n)
    ▸ Remoção
    ▸ Primeiro localiza-se o elemento a ser retirado O(h)
    ▸ Caso recaia no caso 3, deve-se procurar também o elemento a
    substituir o nó a ser retirado O(h)
    ▸ No pior caso tem-se O(n) para uma árvore degenerada
    ▸ No melhor caso O(log n)

     

     

    "Retroceder Nunca Render-se Jamais !"
    Força e Fé !
    Fortuna Audaces Sequitur !

  • Complexidade da busca binária: O(log N)

    Complexidade da busca sequencial: O(N)

  • Força Guerreiro!!!!!!


ID
2789584
Banca
CCV-UFC
Órgão
UFC
Ano
2016
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Com relação à uma árvore binária de busca, assinale a alternativa correta.

Alternativas
Comentários
  • Quem não tem acesso: --> D

  • Gabarito D

    Em Ciência da computação, uma árvore binária de busca (ou árvore binária de pesquisa) é uma estrutura de dados de árvore binária baseada em nós, onde todos os nós da subárvore esquerda possuem um valor numérico inferior ao nó raiz e todos os nós da subárvore direita possuem um valor superior ao nó raiz (esta é a forma padrão, podendo as subárvores serem invertidas, dependendo da aplicação).

    O objetivo desta árvore é estruturar os dados de forma a permitir busca binária.

    "Retroceder Nunca Render-se Jamais !"

    Força e Fé !

    Fortuna Audaces Sequitur !

  • Ao percorrer uma árvore fazemos uma visita sistemática em cada

    um de seus nós.

    A seguir as principais formas de se percorrer os nós de uma

    árvore binária: Em-ordem, pré-ordem, pós-ordem.

    Ou seja, há sim uma ordem pré-definida a ser seguida.

    Gabarito: D

  • a) 0, 1 ou 2 filhos

    b) A complexidade é menor ou igual

    c) Árvore binária de busca não precisa ser cheia nem completa

    d) Para ser uma árvore binária de busca, precisa ser ordenada

    e) Isso é em relação a um árvore binária genérica, não a de busca

  • Pequena correção no comentário do colega Leandro:

    Alternativa A: Uma arvore binaria de busca pode ter 0 ou 2 filhos.

  • Força Guerreiro!!!!!!


ID
2791324
Banca
CCV-UFC
Órgão
UFC
Ano
2013
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

No pior caso, a complexidade do algoritmo conhecido como Busca Linear é:

Alternativas
Comentários
  • Quem não tem acesso: --> C

  • Busca Linear:

    Pior caso: O(n);

    Médio caso: O(n+1)/2;

    Melhor caso: O(1).

    .

    At.te

    Foco na missão

  • Força Guerreiro!!!!!!


ID
2801305
Banca
CESGRANRIO
Órgão
Transpetro
Ano
2018
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Uma das medidas de qualidade do código de um software é a Complexidade, que pode ser medida por meio da complexidade ciclomática.


Considere um grafo de fluxo que possui 5 nós e 12 arcos.


Qual a complexidade ciclomática desse grafo?

Alternativas
Comentários
  •  

    C= (12-5)+2= 9

  • Falou em Complexidade Ciclomática basta lembrar da fórmula = (Nº arcos - Nº Nós) + 2

  • Força Guerreiro!!!!!!

  • Força Guerreiro!!!!!!


ID
2823154
Banca
COMPERVE
Órgão
UFRN
Ano
2018
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

A estrutura de dados de árvore binária é amplamente utilizada na computação, podendo muitas de suas propriedades serem deduzidas na medida de sua necessidade. Ao deduzir a fórmula matemática para a profundidade de uma árvore binária completa de n folhas, constata-se que a alternativa expressando corretamente essa fórmula é

Alternativas
Comentários
  • Força Guerreiro!!!!!!


ID
2876647
Banca
FCM
Órgão
IFN-MG
Ano
2018
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Utilize o método mestre para resolver recorrências das equações abaixo.


T1 (n) = 9T1 (n/3) + n

T2 (n) = T2 (2n/3) + 1


As ordens de complexidade correspondentes são

Alternativas
Comentários
  • Força Guerreiro!!!!!!

  • https://www.blogcyberini.com/2017/11/teorema-mestre.html


ID
2876659
Banca
FCM
Órgão
IFN-MG
Ano
2018
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

A função da Memoização na estratégia Top-Down para a solução de problemas, utilizando Programação Dinâmica, é implementar um algoritmo

Alternativas
Comentários
  • Gabarito A

    Programação dinâmica é um método para a construção de algoritmos para a resolução de problemas computacionais, em especial os de otimização combinatória. Ela é aplicável a problemas nos quais a solução ótima pode ser computada a partir da solução ótima previamente calculada e memorizada - de forma a evitar recálculo - de outros subproblemas que, sobrepostos, compõem o problema original.

    O que um problema de otimização deve ter para que a programação dinâmica seja aplicável são duas principais características: subestrutura ótima e superposição de subproblemas. Um problema apresenta uma subestrutura ótima quando uma solução ótima para o problema contém em seu interior soluções ótimas para subproblemas. A superposição de subproblemas acontece quando um algoritmo recursivo reexamina o mesmo problema muitas vezes.

    Problemas de programação dinâmica podem ser abordados de forma top-down ou bottom-up.

    Top Down

    Como os próprios nomes sugerem, a abordagem top-down aborda o problema de forma recursiva comum, ou seja, no exemplo do algoritmo de Fibonacci (mais abaixo), começamos pelo n-ésimo número e em, recursivamente, ir calculando os valores de F[ n-1 ], F[ n-2 ], F[ n-3 ],..., F[ 2 ], F[ 1 ]. Nesta abordagem, os valores são armazenados em uma tabela e, para a i-ésima iteração, verifica-se se F[ i ] já foi calculado.

    Bottom Up

    Na abordagem bottom-up, vamos calculando os subproblemas menores e aumentando a complexidade com o passar do tempo, ou seja, para o exemplo de Fibonacci, começaríamos calculando F[ 1 ], depois F[ 2 ], F[ 3 ], e assim por diante até F[ n ]. Observe que, nesta abordagem, na nós sabemos que, na i-ésima iteração, F[ i-1 ] já foi resolvido, logo não precisamos verificar toda vez como na top-down. Ao consultar o exemplo 1, do Algortimo de Fibonacci, isso deve ficar mais claro.

    Em geral, ambas as abordagens tem o mesmo tempo assintótico de execução.

    "Retroceder Nunca Render-se Jamais !"

    Força e Fé !

    Fortuna Audaces Sequitur !

  • Força Guerreiro!!!!!!


ID
2876677
Banca
FCM
Órgão
IFN-MG
Ano
2018
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Sobre uma importante classe de complexidade, a classe dos problemas NP-completos, NÃO se pode afirmar que

Alternativas
Comentários
  • Gabarito D

    A lista abaixo contém alguns dos problemas bem conhecidos como NP-completo quando expressados como problemas decisórios:

    Problema de satisfatibilidade booleana (SAT)

    Jogo do 15

    Problema da mochila (Knapsack)

    Tetris

    Problema do ciclo hamiltoniano

    Problema de roteamento de veículos

    Problema do caixeiro viajante

    Problema da Torre de Hanoi

    Problema do isomorfismo de subgrafos

    Problema da soma de subconjuntos

    Problema do clique

    Problema de cobertura de vértices

    Problema de conjuntos independentes

    Vamos na fé !

    "Retroceder Nunca Render-se Jamais !"

    Força e Fé !

    Fortuna Audaces Sequitur !


ID
2876680
Banca
FCM
Órgão
IFN-MG
Ano
2018
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Uma transformação polinomial é uma ferramenta fundamental na demonstração de que determinado problema é NP-difícil.


Avalie as afirmações sobre propriedades que transformações polinomiais devem satisfazer.


I. Para toda transformação polinomial, deve existir uma Máquina de Turing determinística que a computa em tempo polinomial.

II. Se uma transformação polinomial transforma um elemento de linguagem A em um elemento de linguagem B, então A é um subconjunto não necessariamente próprio de B.

III. Se uma transformação polinomial transforma um elemento de uma linguagem A em um elemento de linguagem B, e A pertence a NP, então B pertence a NP.

IV. A quantidade de espaço utilizada pela transformação pode ser limitada por uma constante.


Está correto apenas o que se afirma em

Alternativas
Comentários
  • I. Para toda transformação polinomial, deve existir uma Máquina de Turing determinística que a computa em tempo polinomial.

    IV. A quantidade de espaço utilizada pela transformação pode ser limitada por uma constante.

  • Força Guerreiro!!!!!!


ID
2876689
Banca
FCM
Órgão
IFN-MG
Ano
2018
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Avalie as afirmações abaixo:


I. A classe P e a classe NP são disjuntas.

II. A classe P é um subconjunto da classe co-NP.

III. Problemas coNP-completos admitem um certificado tal que uma resposta negativa pode ser verificada em tempo polinomial.

IV. A interseção das classes NP e co-NP é vazia.


Está correto apenas o que se afirma em

Alternativas
Comentários
  • Força Guerreiro!!!!!!


ID
2891164
Banca
IF-MS
Órgão
IF-MS
Ano
2019
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Considere as seguintes afirmações sobre algoritmos e estruturas de dados:


I. Filas são estruturas do tipo FIFO (First In First Out).

II. A inserção no fim de uma lista duplamente encadeada e não ordenada é realizada em O(n).

O tempo de execução do algoritmo quicksort no pior caso é O(n2 ).


Assinale a opção CORRETA:

Alternativas
Comentários
  • Estão apenas corretas as alternativas

    I. Filas são estruturas do tipo FIFO (First In First Out).

    PRIMEIRO QUE ENTRA PRIMEIRO QUE SAI. Similar à fila de um banco.

     

    III - O tempo de execução do algoritmo quicksort no pior caso é O(n2 ).

    Complexidade no pior caso: O(n2 ). https://uploaddeimagens.com.br/imagens/quicksort_-_cesgranrio-png

  • II. A inserção no fim de uma lista duplamente encadeada e não ordenada é realizada em O(n).

    "Inserção no fim da lista

    Basta realizar operações de atribuições atualizando o ponteiro do fim (e início, quando necessário). Tempo gasto é constante, O(1). Realizada em:

    -> Lista simplesmente encadeada e não ordenada.

    -> Lista duplamente encadeada e não ordenada.

    -> Lista circular simplesmente encadeada e não ordenada.

     -> Lista circular duplamente encadeada e não ordenada"

    Fonte: Estruturas de Dados - Ana Fernanda Gomes Ascencio; Graziela Santos de Araújo;

  • O fato da lista não estar ordenada, cria a necessidade de buscar o elemento final, ou seja, uma estrutura de repetição a mais é necessária para varrer a lista comparando o elemento atual, criando uma complexidade O(n²).

  • d-

    ________________________________________________________________________________________

    Algoritmo            Melhor caso   Pior caso

    ----------------------------------------------------------------------

    Select Sort           n2                n2

    ----------------------------------------------------------------------

    Bubble Sort           n2                n2

    ----------------------------------------------------------------------

    Inserção Direta     n2                 n2

    ----------------------------------------------------------------------

    Heap Sort            nlogn            nlogn

    ----------------------------------------------------------------------

    Merge Sort          nlogn             nlogn

    ----------------------------------------------------------------------

    Quick Sort           nlogn              n2

    ----------------------------------------------------------------------

    ________________________________________________________________________________________

    complexidade de inserção no fim de uma lista duplamente encadeada e não ordenada é

    O(1)

  • Complementando as demais respostas, a complexidade para inserção no fim de uma lista duplamente encadeada é O(1) pois podemos inserir diretamente na posição final. Isto se deve ao fato de ao desenvolver o algoritmo da lista duplamente encadeada, diferente da linear, devemos guardar as posições de início e fim da lista.

    Gabarito D

  • Força Guerreiro!!!!!!

  • Entendi que a questão Raphael Coutinho menciona como "definição" a mim se apresenta mais como uma descrição da atividade do que propriamente uma definição do termo criação

  • Entendi que a questão Raphael Coutinho menciona como "definição" a mim se apresenta mais como uma descrição da atividade do que propriamente uma definição do termo criação


ID
3015613
Banca
FAURGS
Órgão
UFRGS
Ano
2018
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Pesquisa Binária e Hash Code são duas técnicas de busca de dados em um arquivo ou tabela muito usados em informática, com grande vantagem sobre a Pesquisa Sequencial. Sobre essas técnicas, assinale a afirmação INCORRETA.

Alternativas
Comentários
  • e-

    In computing, a hash table (hash map) is a data structure that implements an associative array abstract data type, a structure that can map keys to values. A hash table uses a hash function to compute an index, also called a hash code, into an array of buckets or slots, from which the desired value can be found.

    https://en.wikipedia.org/wiki/Hash_table

  • Força Guerreiro!!!!!!


ID
3030754
Banca
IDECAN
Órgão
IF-PB
Ano
2019
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

O Quick-Sort é considerado o algoritmo de ordenação baseado em comparação mais eficiente, mas em alguns casos sua complexidade é igual ao do Bubble-Sort. Assinale a alternativa que indica a complexidade do Quick-Sort quando o vetor está ordenado em ordem decrescente:

Alternativas
Comentários
  • Questão anulada. A justificativa é que depende da implementação do Quick-Sort.


ID
3064144
Banca
UFMG
Órgão
UFMG
Ano
2019
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

O famoso algoritmo de Dijkstra soluciona um problema de grafos direcionados e não direcionados com uma certa complexidade. Qual é esse problema e qual é essa complexidade?

Alternativas
Comentários
  • PRIMEIRAMENTE: O problema da mochila nunca foi resolvido, sendo assim elimina-se C e D.

    SEGUNDAMENTE: O Dijkstra jamais publicou um algoritmo com complexidade tão ruim - O(n!), assim elimina-se a B.

  • Força Guerreiro!!!!!!


ID
3136039
Banca
Exército
Órgão
EsFCEx
Ano
2019
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Segundo Thomas Cormen, cientistas da computação geralmente consideram problemas resolvíveis por algoritmos de tempo polinomial como “tratáveis”, o que quer dizer “fácil de lidar”. Se existir um algoritmo de tempo polinomial para um problema, então se diz que esse problema está na classe P. A respeito dos algoritmos de redução em tempo polinomial, assinale a alternativa correta.

Alternativas
Comentários
  • essa questão não extrapolou o edital não? alguém chegou a recorrer?

  • Acredito que não extrapolou, pois faz parte do conteúdo cobrado:

    4. Técnicas de programação

    b. Estrutura de dados: vetores, matrizes, cadeia de caracteres, listas lineares, pilhas, filas,

    árvores, grafos, pesquisa de dados, classificação de dados, estruturas e tipos abstratos de dados,

    recursividade, eficiência e complexidade.

    Acredito que essa imagem explique a resposta:

    https://upload.wikimedia.org/wikipedia/commons/thumb/6/66/P_np_np-completo_np-hard.svg/450px-P_np_np-completo_np-hard.svg.png

    Se um problema NP pode ser resolvido em tempo polinomial, logo esse problema seria NP também, pois fazem parte do mesmo conjunto.

  • nessa eu concordo com você Diego, estou lendo o livro do Cormen desde o começo do ano e realmente, no início do capítulo de complexidade eu já aprendi a resolução dessa questão, e esse livro está na bibliografia do concurso, tudo bem que tá no fim do livro kkkk penúltimo capítulo, mas está lá, agora eu aprendi...boa sorte a todos nós!


ID
3136057
Banca
Exército
Órgão
EsFCEx
Ano
2019
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

A notação “O” que determina ordem de complexidade e eficiência de um algoritmo pode ser formalizada como se segue:  


                                        T(n) = O (ƒ(n))

                        Se existirem inteiro m e constante c tais que 

                                 T(n) ≤ cƒ(n) para n > m.


Para uma entrada n e um tempo T, melhorias substanciais podem ser obtidas ao utilizarmos diferentes algoritmos. Assinale a alternativa correta com relação ao tempo de execução, para uma mesma entrada (n), porém utilizando algoritmos diferentes. 

Considere as seguintes ordens de complexidade no tempo:  

                       T1(n) = n, T2(n) = nlogn, T3(n) = n² , T4(n) = 2n 

Alternativas
Comentários
  • Em relação ao tempo de execução, quanto mais complexo a função, maior o tempo de execução.

    O(n!) > O(2^n) > O(n^2) > O(nlogn) > O(n) > O(logn) > O(1).

    Logo, T4(n) > T3(n) > T2(n) > T1(n).

    T2 < T3.

    Fonte: <https://medium.com/nagoya-foundation/introdu%C3%A7%C3%A3o-%C3%A0-complexidade-de-algoritmos-4a9c237e4ecc>.

  • O problema da alterantica C é que no enunciado não coloca T4(n)=2^n e aí fica com a A e C corretas. Acho que foi erro de digitação do Qconcursos

  • der o valor de n= 10 calcule e veja o gabarito

ID
3136186
Banca
Exército
Órgão
EsFCEx
Ano
2019
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Considere um sistema DASH que disponibiliza N versões de vídeo e M versões de áudio e permite que o dispositivo de reprodução escolha, a qualquer momento, qualquer uma das N versões de vídeo e qualquer uma das M versões de áudio. O servidor cria arquivos misturando áudio e vídeo em um único arquivo. Assinale a alternativa que indique corretamente a quantidade de arquivos que o servidor precisa armazenar.

Alternativas
Comentários
  • em que momento a questão fala que as M versões de áudio são vinculadas dependendo do vídeo? se o processamento gerar vídeo + áudio independentemente seria necessário armazenamento N+M, não?

    Outro ponto: sistemas DASH extrapolam o edital, ou não?

    Aliás, prova pesada da esfcex esse ano ein...

  • Nessa eu fui pelo racícionio do que foi dito no comando da questão, "...permite que o dispositivo de reprodução escolha, a qualquer momento, qualquer uma das N versões de vídeo e qualquer uma das M versões de áudio.", sendo assim, seria como uma matrix NxM, em que cada elemento seria um arquivo combinando um vídeo e um áudio qualquer.

    Acredito que sobre o edital, o sistema DASH estaria nesta parte em negrito:

    3. Comunicação de dados

    b. Redes de computadores: conceitos, topologias e principais componentes; Qualidade de

    Serviços; Protocolos de comunicação e roteamento (incluindo os padrões OSI/ISO, TCP/IP e

    ITU-T); Redes sem fio; Protocolos e serviços para Voz sobre IP (VoIP) e streaming de áudio e

    vídeo;

    Mas concordo com você Leandro, essa prova teve uma outra roupagem, diferentes das outras, acredito que seja por causa da mudança de banca. Assim como houve a mudança do formato de prova desde o começo de 2006 até 2010, não sou dessa época, mas eu dei uma olhada nas provas anteriores, e as primeiras provas que surgiram da EsFCEx na área de Informática eram muito mais difíceis que essas atuais.

    Fonte: <https://www.gta.ufrj.br/ensino/eel879/vf/mpeg-dash/#aplic>

  • Diego, mas não falo nem pelo edital, falo pela sugestão de bibliografia que tem no site. Nenhum livro da bibliografia cita sistemas DASH, eu me dei o trabalho de procurar kkkk... Eu entraria com recurso nessa e em várias outras fácil dessa prova... Tem sugestão de bibliografia para isso ué, TI é infinito e delimitar é justamente a parte boa do concurso da ESFCEX, fazer quem estuda mais passar, pois a amostragem é a partir de um conjunto finito de livros que alguém pode ler e resumir, e não a partir do infinito igual nos concursos comuns, que entram desde os livros até wiki e devmedia e por aí vai...Agora nem isso mais...

  • Essa é uma questão de estrutura de dados que aborda o conceito de Vetores e Matrizes. Basta tratar N como as linhas e M como as colunas, será feita uma matriz NxM, onde eu tenho todas as combinações possíveis, logo, a quantidade de registros será Linhas x Colunas (Alternativa C, NM). Uma questão bastante interessante.

  • se você combina as versões não precisa guardar arquivos redundantes

ID
3209908
Banca
FGV
Órgão
SEE-PE
Ano
2016
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Um método de busca bastante utilizado, conhecido como hash, baseia-se na utilização que mapeia chaves em endereços de memória, de modo que os dados associados a cada chave possam ser rapidamente localizados e lidos. Quando há conflitos de localização, algum algoritmo de separação é adotado.

Considere uma tabela hash armazenada em um arquivo no disco rígido. Supondo-se que a mesma possua uma função de hash razoavelmente protegida de conflitos, o número médio de acessos ao disco, necessários para localizar uma chave em um universo de N chaves, é mais próximo de

Alternativas

ID
3292114
Banca
AOCP
Órgão
FUNPAPA
Ano
2018
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Referente à análise da complexidade de algoritmos, preencha as lacunas e assinale a alternativa correta.


Um ___________ é, em outras palavras, uma norma executável para estabelecer um determinado efeito desejado, que na prática será geralmente a obtenção de uma solução a certo tipo de problema. O conceito central da ______________ e da ciência da computação é o de algoritmo.

Alternativas
Comentários
  • algoritmo é genérico, pode se encaixar em qualquer contexto e não necessariamente ser executado por computadores. O início do texto tem essas características, por isso a resposta é algoritmo e programação.
  • Dá pra acertar, mas que questão bem displicente, o examinador não deve ser da área de T.I.

    Copia e cola da página 3: http://valdick.com/files/Estrutura_de_%20Dados_e_Algoritmos_Lavras.pdf

    GABARITO ALTERNATIVA E

  • Força Guerreiro!!!!!!


ID
3358183
Banca
FUNDEP (Gestão de Concursos)
Órgão
Prefeitura de Pará de Minas - MG
Ano
2018
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

A seguir são apresentados alguns resultados do cálculo da complexidade média de alguns algoritmos conhecidos para ordenação de vetores.

Qual entre eles apresenta um bom fator de complexidade em sua execução e deve ser utilizado?

Alternativas
Comentários
  • O(N) Possui um nível de complexidade razoável e de menor complexidade que O(n2) e O(n3).

    A O(2n) não existe.

  • GABARITO LETRA A)

    A complexidade O(n) representa a complexidade linear, frente a complexidade exponencial das outras alternativas.

    OBS: A complexidade O(2^n) existe, apesar de ser pouco usual, explico: A complexidade, segundo CORMEN, nada mais é do que representar o custo de um algoritmo através de funções matemáticas, em essência define-se uma função como limite superior(pior caso) e outra função como limite inferior(melhor caso).

  • Força Guerreiro!!!!!!


ID
3379141
Banca
INSTITUTO AOCP
Órgão
UFOB
Ano
2018
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Sobre as Estruturas de Dados, seus conceitos e usos, julgue, como VERDADEIRO ou FALSO, os itens a seguir.

Um algoritmo de complexidade nlogn é mais complexo que um algoritmo de complexidade n2 .

Alternativas
Comentários
  • Para essa questão era preciso ter decorado uma tabela com a notação e o nome.

    Na escala podemos perceber que a complexidade de (n2) é maior do que a de (n log n)

  • GABARITO ERRADO

    Os algoritmos nlogn são menos complexos(termo usado nessa questão como sinônimo de lento) do que aqueles n2. Vale lembrar da tabela de complexidade.

  • Demonstrando (eu acho), me corrijam se eu não lembro muito de matemática:

    n = 100

    n2 = 10.000

    nlogn (creio que é na base 10) = 100 log 100 (se a base é 10, o log de 100 na base 10 é 2, então:) = 100x2 = 200

    Pela matemática, que espero estar correta, dá para responder a questão

  • A escala a qual os colegas se referem é esta: https://image.slidesharecdn.com/apresentacao-141117144156-conversion-gate01/95/complexidade-de-algoritmos-notao-assinttica-algoritmos-polinomiais-e-intratveis-15-638.jpg?cb=1416235430

  • Força Guerreiro!!!!!!


ID
3527974
Banca
INSTITUTO AOCP
Órgão
UFFS
Ano
2016
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Na análise de complexidade de algoritmos, em que o interesse é restrito a valores assintóticos e se desconsidera as constantes multiplicativas e aditivas, qual é o número de passos a ser considerado na expressão 2(n2-1) + 10n3?

Alternativas
Comentários
  • Quando se considera o número de passos efetuados por um algoritmo podem-se desprezar constantes aditivas ou multiplicativas. Por exemplo, um valor de número de passos igual a 3n será aproximado para n. Além disso, como o interesse é restrito a valores assintóticos, termos de menor grau também podem ser desprezados. Assim, um valor de número de passos igual a n² + n será aproximado para n². O valor 6n³ + 4n – 9 será transformado em n³.

    Alternativa: D

  • Força Guerreiro!!!!!!


ID
3546319
Banca
SUGEP - UFRPE
Órgão
UFRPE
Ano
2019
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Os algoritmos de ordenação são utilizados para os mais diversos cenários de dados. Apesar de terem o mesmo objetivo (ordenação), possuem diferentes complexidades em relação ao número (n) de elementos a serem ordenados. O “quiksort” se destaca como um dos algoritmos mais rápidos para ordenação. No pior caso, a complexidade “quicksort” será:

Alternativas
Comentários
  • Quicksort

    Possui complexidade O(n²) no pior caso e O(n log n) no caso médio;

    Alternativa: D

  • A maioria dos algoritmos de ordenação tem a pior complexidade O(n²)

  • Algoritmo            Melhor caso   Pior caso

    ----------------------------------------------------------------------

    Select Sort           n2                n2

    ----------------------------------------------------------------------

    Bubble Sort           n2                n2

    ----------------------------------------------------------------------

    Inserção Direta     n2                 n2

    ----------------------------------------------------------------------

    Heap Sort            nlogn            nlogn

    ----------------------------------------------------------------------

    Merge Sort          nlogn             nlogn

    ----------------------------------------------------------------------

    Quick Sort           nlogn              n2

    ----------------------------------------------------------------------

  • Força Guerreiro!!!!!!


ID
3764044
Banca
INSTITUTO AOCP
Órgão
Prefeitura de Betim - MG
Ano
2020
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Um algoritmo que apresenta a menor complexidade dentre todos os possíveis algoritmos para resolver o mesmo problema é considerado um algoritmo

Alternativas
Comentários
  • Se um algoritmo tem uma complexidade que é igual ao limite inferior do problema então o algoritmo é ótimo.

    Um problema é dito fechado, quando o limite superior e inferior são iguais.

    Um problema é dito aberto, quando o limite superior e inferior são diferentes.

  • Algoritmos ótimos é aquele que apresenta a menor complexidade dentre todos os possíveis algoritmos para resolver o mesmo problema.

  • Força Guerreiro!!!!!!


ID
3832699
Banca
INSTITUTO AOCP
Órgão
Prefeitura de Novo Hamburgo - RS
Ano
2020
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Assinale a alternativa que apresenta o tempo de execução do pior caso e do melhor caso para o algoritmo quicksort ou ordenação rápida.

Alternativas
Comentários
  • Não tenho na mente o funcionamento exato do algoritmo informado pela questão, mas basta sabermos a precedência das classes de complexidade de algoritmos e marcar a assertiva onde tenha a maior complexidade para o pior caso e a menor complexidade para o melhor caso! Alternativa E

    A maioria dos algoritmos de ordenação tem o pior caso de complexidade O(n^2)

  • @Homelander, seguindo essa lógica, seria letra A.

    O(n) é menos complexo do que O(n lg n)

  • O Felipe Jansen foi cirúrgico no raciocínio. Essa estratégia pode ser usada em vários tipos de questões.

    E de fato o pior cenário para o QuickSort é O(n²) e o melhor cenário O(n log(n))

  • Força Guerreiro!!!!!!

  • GABARITO E

    Quick Sort

    • Melhor caso: O(n log n)
    • Médio caso: O(n log n)
    • Pior caso: O(n²)

ID
4141015
Banca
COMPERVE
Órgão
UFRN
Ano
2016
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Analise os dois algoritmos a seguir:


Algoritmo1: Algoritmo2:


função algo(n) função algo(n)

se n < 2 então i <- 1

retorne n j <- 0

caso contrário para k de 1 até n faça

retorne algo(n - 1) + algo(n - 2) x <- i + j

i <- j

j <- x

retorne j


Em relação aos algoritmos expostos, é correto afirmar que

Alternativas
Comentários
  • Questão sem formatação alguma, como de costume o site se preocupa em quantidade, mas não em qualidade, só é possível entender algo e responder indo direto para o arquivo da prova.

  • Força Guerreiro!!!!!!


ID
4179916
Banca
FUMARC
Órgão
Câmara de Carmo do Cajuru - MG
Ano
2018
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Função de complexidade de algoritmos, cujo tempo de execução ocorre tipicamente em algoritmos que resolvem um problema quebrando-o em problemas menores, resolvendo cada um deles independentemente e, depois, ajuntando as soluções:

Alternativas
Comentários
  • c = São algoritmos de complexidade nLogn. Ocorre tipicamente em algoritmos que dividem problemas em problemas menores, porém juntando posteriormente a solução dos problemas menores.

  • Fonte: https://pt.wikipedia.org/wiki/Complexidade_log-linear

  • Força Guerreiro!!!!!!


ID
4180927
Banca
CETRO
Órgão
AMAZUL
Ano
2015
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

É correto afirmar que a complexidade assintótica de algoritmos é usada

Alternativas
Comentários
  • A eficiência assintótica observa apenas as entradas grandes o suficiente para tornar relevante apenas a ordem de crescimento do tempo de execução. � Não serão consideradas constantes aditivas ou multiplicativas na expressão matemática obtida. � Notação Assintótica � Depois de simplificar a expressão, ficaremos apenas com a parte da função de maior complexidade. � Por exemplo: � Um valor de número de passos igual a 3n será aproximado para n. � Um valor de número de passos igual n 2 + 2 será aproximado para n 2 .

  • Força Guerreiro!!!!!!


ID
4182682
Banca
IFPI
Órgão
IF-PI
Ano
2016
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Considere o código-fonte que segue:


int f1(int n) {

     if (n == 0 II n == 1) return n;

     else return (2 * f1(n-1) + 3 * f1(n-2)); }

int f2(int n) {

     int a; int[] X = new int [n];

     int[] X = new int [n]; int[] Z = new int [n];

      X [0] = Y [0] = Z [0] = 0;

      X [1] = 1; Y [1] = 2; Z [1] = 3;

      for (a = 2; a <= n; a ++) {

            X [a] = Y [a-1] + Z [a-2];

            Y [a] = 2 * X [a]; Z [a] = 3 * X [a]; }

      return X [n]; }


Qual é o tempo de execução de f1(n) e f2(n), respectivamente? 

Alternativas
Comentários
  • F1 temos fibonacci recursivo, que tem complexidade O(2n).

    F2 temos fibonacci não recursivo, que tem complexidade O(n).

    Esse é um assunto que não tenho domínio, então se alguém tiver algo a acrescentar ou mesmo retificar, eu agradeceria.

  • Força Guerreiro!!!!!!

  • Nem ferrando que fibonacci recursivo é 2n...

    Deveria ser 2^n

  • @Leandro Henrique concordo contigo. Imagino que seja 2 elevado a N, porém, na hora de pega a questão perderam esse detalhe.

  • Pensei o mesmo que o Leandro, acabei fazendo por eliminação. Pode ter sido na transcrição da questão


ID
4834132
Banca
Exército
Órgão
EsFCEx
Ano
2020
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

A operação de busca em uma árvore B, no pior caso, tem complexidade de tempo equivalente a:

Alternativas
Comentários
  • De Ordem Logarítmica: Soluções que DIVIDEM o problema em PROBLEMAS MENORES, processando a a cada iteração, em geral, a metade dos dados da vez anterior.

  • Trata-se de uma questão sobre complexidade de algoritmos.

    O comando da questão pergunta qual a complexidade, no pior caso, de uma busca em uma árvore B.

    Essa questão é extremamente difícil. Vamos relembrar as complexidades de uma árvore B pela respectiva operação.

    Busca: Pior caso e caso médio tem ambas O(log n).

    Inserção: Também, assim com a busca, tanto no pior caso quanto no caso médio tem O(log n).


    Gabarito do Professor: Letra B.
  • Algoritmo          | Caso Médio  | Pior Caso

    Espaço             | O(n)             | O(n)

    Busca              | O (log n)        | O(log n)

    Inserção           | O (log n)        | O(log n)

    Remoção         | O (log n)        | O(log n)

    Fonte: https://pt.wikipedia.org/wiki/%C3%81rvore_B

    Resposta correta letra (b)

  • A complexidade de algoritmos é a capacidade de se avaliar a algoritmo de um programa - sua eficiência de execução independente de plataforma ou não.

    https://www.google.com/search?q=complexidade+de+algoritmos&sxsrf=APq-WBvgftB1Sci0RPvmUCrZNvJrpFLgEw:1644526963394&source=lnms&tbm=isch&sa=X&ved=2ahUKEwiRrOerhPb1AhWUrJUCHYz4BkIQ_AUoAnoECAIQBA&biw=1242&bih=577&dpr=1.1#imgrc=zZTtxoe4gC4mxM

    Como podemos observar no link acima existe várias complexidade as mais acima são mais complexas ou seja menos eficiente na hora de buscas... porém mais eficiente em criação de algoritmos de criptografia, as mais a baixo são melhor em buscas, inserções etc..

    No exemplo dado a complexidade O(log n) é baixa, pois a arvore B divide a busca em lados esquerdos da arvore sendo os menores valores e os direitos maiores, ou seja vc quebra a complexidade de busca pela metade.


ID
5279629
Banca
Marinha
Órgão
Comando do 2º Distrito Naval
Ano
2020
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Coloque F (falso) ou V (verdadeiro) nas funções abaixo, considerando a notação de complexidade O, e assinale a seguir a opção correta.


( ) f - 9 + log n = 0(n)

( ) f= 255 = 0(1)

( ) f = 37 + 215n = 0(2n)

( ) f=25 + 218+n = 0(2n)

Alternativas
Comentários
  • Quando se fala de complexidade utilizando o BIG O, pode-se desprezar constantes aditivos e multiplicativas.

    Nesse caso a questão está querendo saber qual é a complexidade de pior caso. Para saber isso é necessário saber quais são as possíveis complexidades e sua ordem.

    O(1) = Constante

    O(log n) = logarítmica

    O(log^2 n) = log quadrática

    O(n log n) = n log n

    O(n) = linear

    O(n^2) = quadrática

    O(n^3) = cubica

    O(2^n) = exponencial

    ================================

    - 9 + log n = 0(n) => CERTO

    f= 255 = 0(1) => CERTO

    = 37 + 215n = 0(2n) => ERRADO - O(2^15N) possui a maior complexidade que a O(2^n)

    f=25 + 218+n = 0(2n) => CERTO

    Alternativa: B


ID
5330437
Banca
Exército
Órgão
EsFCEx
Ano
2020
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

A operação de busca em uma árvore B, no pior caso, tem complexidade de tempo equivalente a:

Alternativas
Comentários
  • - Uma árvore balanceada, após inclusões, alterações e exclusões, deve manter o custo dessas operações em O(log n).

    - Cada subárvore que contém m nós deve possuir altura igual a O(log n).

    - Árvores balanceadas: árvores AVL, árvore Graduada, árvores B e arvore rubro-negra.

    Alternativa: B

  • Complexidade Logarítmica​

    • São os algoritmos de complexidade O(logN).​
    • Ocorre tipicamente em algoritmos que dividem o problema em problemas menores.​
    • Ex.: O algoritmo de Busca Binária

    Resposta: B

  • Complementando a resposta dos colegas: Alocação Binaria - 0(log N) / Alocação Sequencial (Vetores/Matrizes) = 0(n)


ID
5474710
Banca
CESGRANRIO
Órgão
Banco do Brasil
Ano
2021
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

O gerente de uma agência bancária recebe, diariamente, solicitações de seus clientes com dúvidas sobre a melhor decisão para aplicações financeiras e as armazena, com um código numérico crescente, num vetor de solicitações, para respondê-las ao final do expediente. Para manter o conceito de bom atendimento, o gerente gostaria, sempre que possível, que a ordem das respostas seguisse, estritamente, a ordem de chegada das solicitações. Entretanto, há casos em que é necessário, por motivos de emergência ou por prioridade legal, localizar determinado código numérico para atender à solicitação correspondente antes das demais, “furando” a fila de espera. O gerente solicitou, então, à equipe de TI do banco, uma proposta que conciliasse essas duas necessidades. Ao estudar o problema, a equipe de TI concluiu que uma solução que mapearia diretamente essa necessidade da gerência seria permitir a realização de uma busca binária sobre o vetor de solicitações ordenado pelos seus códigos numéricos.

Verificando a viabilidade dessa sugestão, o grupo de TI calculou que, se considerar a existência de N solicitações, a quantidade de iterações necessárias para localizar determinado código numérico no vetor de solitações, utilizando a busca binária, no pior caso, é

Alternativas

ID
5526559
Banca
FGV
Órgão
FUNSAÚDE - CE
Ano
2021
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Considere o pseudocódigo abaixo, que define uma função que recebe dois arrays, A1, A2, cada um com N elementos indexados a partir de 1, e retorna o número de elementos do array A1 que não aparecem em A2.
function xpto(A1, A2, N)
     contagem=0
     for i=1 to N
            flag=0
            for j=1 to N
                 if A1[i] == A2[j] then flag=1
                 if flag == 0 then contagem=contagem + 1
        return contagem
Exatamente como foi codificado, o algoritmo da função xpto tem complexidade

Alternativas
Comentários
  • 2 laços aninhados = O(n^2)

  • Complementando o colega Leandro, nem sempre 2 laços aninhados serão O(n^2), se existir alguma condição de parada em algum dos laços for a complexidade será O(n).

  • Sentenças simples: Possuem complexidade constante, ou seja, O(1).

    # Sentenças simples

    s = "Brasil"

    i = 42

    i += 1

    Laços simples: Possuem complexidade linear no tamanho da entrada, ou seja, O(n), em que nn é o tamanho da entrada.

    # Laços simples

    for i in range(n):

      # Sentenças simples

    Laços aninhados: Possuem complexidade quadrática no tamanho da entrada, ou seja, O(n2), em que nn é o tamanho da entrada.

    # Laços aninhados

    for i in range(n):

      for j in range(n):

        # Sentenças simples

    https://algoritmosempython.com.br/cursos/algoritmos-python/analise-complexidade/regras-analise-complexidade/


ID
5532391
Banca
FGV
Órgão
TJ-RO
Ano
2021
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

João precisa codificar uma função f(A), onde A é um array unidimensional de números inteiros, que deve retornar o maior valor armazenado em A.
A complexidade de um algoritmo eficiente para a função f, para um array com n (n  1) elementos, deveria ser: 

Alternativas
Comentários
  • Para saber o maior valor do array unidimensional, preciso percorrer todos os elementos: O(n)

    Se o array fosse ordenado, seria O(1)

    Se o array fosse bidimensional, seria O(n*m) [ou O(n^2) se tiver o mesmo número de linhas e colunas]

  • falou em eficiencia, é O(n)


ID
5605678
Banca
FGV
Órgão
Banestes
Ano
2021
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

João pretende armazenar uma coleção de dados referentes a cerca de um milhão de pessoas. Cada pessoa tem como chave de acesso um número inteiro sequencial, que não se repete.


Empregando uma estrutura de Tabela Hash, João conseguiria obter, praticamente, acesso com complexidade:

Alternativas
Comentários
  • Gab A. A implementação típica busca uma função hash que seja de complexidade O(1), não importando o número de registros na tabela (desconsiderando colisões). O ganho com relação a outras estruturas associativas (como um vetor simples) passa a ser maior conforme a quantidade de dados aumenta.