Questões de Concurso
Sobre estrutura de dados em algoritmos e estrutura de dados
Foram encontradas 1.673 questões
Código 01 import java.util.Stack; public class PilhaExemplo { public static void main(String[] args) { Stack<Integer> pilha = new Stack<>(); pilha.push(10); pilha.push(20); pilha.push(30); System.out.println("Elementos removidos da pilha:"); while (!pilha.isEmpty()) { System.out.println(pilha.pop()); } } } Código 02 import java.util.LinkedList; import java.util.Queue; public class FilaExemplo { public static void main(String[] args) { Queue<Integer> fila = new LinkedList<>(); fila.add(10); fila.add(20); fila.add(30); System.out.println("Elementos removidos da fila:"); while (!fila.isEmpty()) { System.out.println(fila.poll()); } } }
Com base nos dois trechos de código apresentados, assinale a alternativa correta ao comparar o código da pilha com o código da fila.
public class HeapSort { public void heapSort(int arr[]) { int n = arr.length; for (int i = n / 2 - 1; i >= 0; i--) { heapify(arr, n, i); } for (int i = n - 1; i > 0; i--) { int temp = arr[0]; arr[0] = arr[i]; arr[i] = temp; heapify(arr, i, 0); } } void heapify(int arr[], int n, int i) { int maior = i; int esquerda = 2 * i + 1; int direita = 2 * i + 2; if (esquerda < n && arr[esquerda] > arr[maior]) { maior = esquerda; } if (direita < n && arr[direita] > arr[maior]) { maior = direita; } if (maior != i) { int temp = arr[i]; arr[i] = arr[maior]; arr[maior] = temp; heapify(arr, n, maior); } } public static void main(String args[]) { int arr[] = {12, 11, 13, 5, 6, 7}; int n = arr.length; HeapSort heapSort = new HeapSort(); heapSort.heapSort(arr); System.out.println("Array ordenado: "); for (int i : arr) { System.out.print(i + " "); } } }
Considerando o algoritmo apresentado, qual é a principal característica deste algoritmo de ordenação?
Código 01 import java.util.Stack; public class Pilha { public static void main(String[] args) { Stack<Integer> pilha = new Stack<>(); pilha.push(5); pilha.push(3); pilha.push(8); pilha.push(1); Stack<Integer> pilhaOrdenada = new Stack<>(); while (!pilha.isEmpty()) { int temp = pilha.pop(); while (!pilhaOrdenada.isEmpty() && temp > pilhaOrdenada.peek()) { pilha.push(pilhaOrdenada.pop()); } pilhaOrdenada.push(temp); } System.out.println("Pilha Ordenada: " + pilhaOrdenada); } }
Código 02
import java.util.Stack; public class Pilha { public static void main(String[] args) { Stack<Integer> pilha = new Stack<>(); pilha.push(5); pilha.push(3); pilha.push(8); pilha.push(1); Stack<Integer> pilhaOrdenada = new Stack<>(); while (!pilha.isEmpty()) { int temp = pilha.pop(); while (!pilhaOrdenada.isEmpty() && temp < pilhaOrdenada.peek()) { pilha.push(pilhaOrdenada.pop()); } pilhaOrdenada.push(temp); } System.out.println("Pilha Ordenada: " + pilhaOrdenada); } }
Ao comparar os dois códigos apresentados, assinale a alternativa correta.
(__)Vetores e matrizes são estruturas de dados homogêneas que armazenam elementos do mesmo tipo em posições contíguas de memória.
(__)A estrutura do tipo fila segue a política LIFO (Last In, First Out), onde o último elemento a entrar é o primeiro a ser removido.
(__)Pilhas são estruturas lineares que utilizam o princípio FIFO (First In, First Out) para o controle de inserção e exclusão de itens.
(__)Árvores binárias de busca permitem organizar dados de forma hierárquica, facilitando operações de localização e ordenação de chaves.
Após análise, assinale a alternativa que apresenta a sequência correta dos itens acima, de cima para baixo:
Em hashing com encadeamento (separate chaining), armazenando n chaves em uma tabela de tamanho m, o fator de carga α é definido por α = _______________. Para uma função hash que aproxima hashing uniforme simples, o tempo médio esperado de uma operação de busca bem-sucedida é O(1 + ________________).
A sequência que preenche corretamente as lacunas é:
I. Um percurso em ordem (INORDER-TREE-WALK) em T imprime (ou produz) as chaves em ordem crescente (não decrescente).
PORQUE
II. O tempo de execução do procedimento INORDER-TREE-WALK é O(n2), pois sua complexidade não depende apenas do número total de nós processados.
Considerando o cenário ideal de funcionamento de uma tabela hash, em que a função hash distribui uniformemente as chaves e há baixa ocorrência de colisões, assinale a alternativa que representa CORRETAIVENTE a complexidade da operação de busca nessa estrutura.
ArrayList lista = new ArrayList<Float>();
Set set = new HashSet<Integer>();
Stack pilha = new Stack<Integer>();
pilha.push(4);
pilha.push(2);
pilha.push(7);
pilha.pop();
set.add(8);
set.add(4);
set.add(8);
lista.add(1f);
lista.add(3f);
lista.add(7f);
lista.remove(1);
System.out.println(lista);
System.out.println(set);
System.out.println(pilha);
A saída correta desse trecho de código é
lista1 = []
for i in range(3):
a = []
for j in range(3):
a.append(i) lista1.append(a)
lista2 = lista1
lista2[0] = [4, 2, 1]
lista1[1][2] = 3
lista1[2] = [1, 2, 4]
print(lista1, lista2)
A saída correta no console ao executar esse código é
função busca1(x) 1. i := 1 2. busca1 := 0 3. enquanto i ≤ n faça 4. se L[i].chave = x então 5. busca1 := i 6. i := n + 1 7. senão i := i + 1
função busca2(x) 1. i := 1 2. L[n + 1].chave := x 3. enquanto L[i].chave ≠ x faça 4. i := i + 1 5. se i ≠ n + 1 então busca2 := i 6. senão busca2 := 0
Com base nas informações dadas, é correto afirmar:
( ) Enquanto uma pilha permite a inserção e a eliminação de elementos em apenas uma extremidade, uma fila permite a inserção em uma extremidade e a eliminação na outra.
( ) Em uma lista circular duplamente encadeada, o ponteiro anterior do início da lista aponta para o fim, e o ponteiro próximo do fim da lista aponta para o início.
( ) Para remover um elemento de uma lista simplesmente encadeada, deve-se alterar o encadeamento dos elementos anterior e próximo ao elemento removido.
A sequência correta, de cima para baixo, é
I. Esse método aproveita a possibilidade de acesso randômico à memória para alcançar uma complexidade temporal média por operação de O(1), sendo o pior caso, entretanto, O(log n), em que n é a quantidade de chaves a serem armazenadas na tabela.
II. Uma das estratégias conhecidas para tratar colisões consiste em armazenar as chaves com o mesmo endereço-base em listas encadeadas. As listas podem se encontrar no exterior da tabela ou compartilhar o mesmo espaço dela.
III. A ideia básica do método de endereçamento aberto para tratamento de colisões é, caso ainda haja espaço, armazenar as chaves com o mesmo endereço-base na própria tabela, mas sem a necessidade da criação de listas encadeadas.
Com relação a essas afirmativas, pode-se afirmar que
contador <-0 PARA I DE 1 ATÉ 10 FAÇA SE habitantes[i] > 50000 ENTÃO contador <- contador + 1 FIM SE FIM PARA
Considerando que a variável "habitantes" é um vetor com pelo menos 100 valores, assinale a alternativa que identifica CORRETAMENTE o que o algoritmo apresentado faz