Questões de Concurso sobre Pilhas

Considere uma estrutura de pilha (FILO) preenchida inicialmente com os seguintes inteiros: 1, 2, 3, 4, 5, 6, nessa ordem, do primeiro ao último a entrar na pilha. Suponha que executemos os seguintes comandos de atribuições a variáveis inteiras, alternados com comandos de pilha:

VAR1:= 7; VAR2:=8; VAR3:=9;

VAR4:=POP;

PUSH(VAR1);

PUSH(VAR2);

VAR1:=POP;

VAR2:=POP;

PUSH(VAR3);

PUSH(VAR1);

PUSH(VAR2);

PUSH(VAR4);

Assim, em quanto resulta o conteúdo da pilha?

Em uma estrutura de dados do tipo pilha, existem operações essenciais ao seu funcionamento. A operação denominada PUSH

Considere a estrutura de dados do tipo pilha. Se a pilha estiver vazia então topo = λ, sabe-se que pt é um ponteiro. Analise o algoritmo abaixo

se topo ≠ λ então

pt := topo

topo := topo ↑.prox

valor- recuperado := pt ↑.info

desocupar(pt)

senão underflow

O algoritmo descreve a operação de

A estrutura de pilha é essencial para organização e gerenciamento de informações; por meio de sua utilização, é possível realizar operações de gerenciamento de memória, organizar o histórico de navegação em Web browsers, implementar funcionalidades de desfazer e refazer, realizar análises sintática e semântica de códigos em compiladores e interpretadores entre outras possibilidades. Refletindo sobre isso, assinale a alternativa correta que descreve uma estrutura de pilha

Assinale a alternativa que representa uma estrutura de dados do tipo LIFO (Last In First Out).

Segundo Sebesta (2018), considere uma estrutura de dados do tipo PILHA, inicialmente vazia, que possui as operações típicas de inserção e remoção de elementos. Nessa estrutura, foram executadas as seguintes operações, de modo ordenado:

PUSH 1

PUSH 2

POP

PUSH 3

POP

PUSH 4

POP

PUSH 5

PUSH 6

POP

PUSH 7

Assinale a opção que apresenta corretamente o número de elementos na pilha e o valor armazenado no topo da pilha, respectivamente, após a realização de todas as operações.

As estruturas de dados de pilha, fila e lista ligada diferem entre si, porque pilha implementa ______, enquanto fila implementa _____ e lista ligada tem _______________________.

Assinale a alternativa que preenche, correta e respectivamente, as lacunas do trecho acima.

Analise os códigos a seguir:

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.

Em estruturas de dados, existem conjuntos __________________ nos quais o elemento removido do conjunto pela operação ‘Delete’, por exemplo, é especificado previamente. Em uma ___________, o elemento eliminado do conjunto é o mais recente inserido, a política implementada é “último a entrar, primeiro a sair”, ou LIFO (last-in, first-out). Já em uma ____________, o elemento eliminado é sempre o que estava no conjunto a mais tempo, a política implementada é “primeiro a entrar, primeiro a sair”, ou FIFO (first-in, first-out).

Assinale a alternativa que preenche, correta e respectivamente, as lacunas do trecho acima.

Em uma estrutura de dados do tipo pilha, manipula-se um elemento dessa estrutura por meio de uma de suas extremidades, denominada

Ao processar uma função recursiva, por padrão, as chamadas recursivas são armazenadas na estrutura de dados:

A seção de layout de memória de um processo conhecida como seção pilha é responsável pelo(a)

Estruturas de Dados são formas de organizar sistematicamente os dados em um programa definindo as operações que podem ser utilizadas para manipular os dados naquela estrutura. As estruturas básicas são diferentes entre si, em geral, na forma de inserir, retirar e organizar os dados internamente. Neste sentido, analise o seguinte código de uma estrutura de dados escrita na linguagem C.

#include <stdio.h>

#include <stdlib.h>

#define MAX_SIZE 100 // Tamanho máximo da estrutura

// Definindo a estrutura

typedef struct {

int items[MAX_SIZE];

int inicio; // Índice do inicio da estrutura

} Estrutura;

// Função para inicializar a estrutura

void initializeEstrutura(Estrutura *estrutura) {

estrutura->inicio = -1;

}

// Função para verificar se a estrutura está vazia

int isEmpty(Estrutura *estrutura) {

return estrutura->inicio == -1;

}

// Função para verificar se a estrutura está cheia

int isFull(Estrutura *estrutura) {

return estrutura->inicio == MAX_SIZE - 1;

}

// Função para inserir um elemento na estrutura

void insert(Estrutura *estrutura, int value) {

if (isFull(estrutura)) { // Verifica se a estrutura está cheia

printf("Erro: Estrutura cheia!\n");

return;

}

estrutura->items[++estrutura->inicio] = value;

}

// Função para remover um elemento da estrutura

int extract(Estrutura *estrutura) {

if (isEmpty(estrutura)) { // Verifica se a estrutura está vazia

printf("Erro: Estrutura vazia!\n");

exit(1);

}

return estrutura->items[estrutura->inicio--];

}

// Função para visualizar o elemento no inicio da estrutura sem

removê-lo

int peek(Estrutura *estrutura) {

if (isEmpty(estrutura)) { // Verifica se a estrutura está vazia

printf("Erro: Estrutura vazia!\n");

exit(1);

}

return estrutura->items[estrutura->inicio];

}

int main() {

Estrutura estrutura;

initializeEstrutura(&estrutura); // Inicializa a estrutura

// Testando as operações da estrutura

insert(&estrutura, 10);

insert(&estrutura, 20);

insert(&estrutura, 30);

printf("Elemento no inicio da estrutura: %d\n",

peek(&estrutura));

printf("Removendo: %d\n", extract(&estrutura));

printf("Removendo: %d\n", extract(&estrutura));

printf("Removendo: %d\n", extract(&estrutura));

printf("A estrutura está vazia? %s\n", isEmpty(&estrutura) ?

"Sim" : "Não");

return 0;

}

O código apresentado é condizente com a estrutura de dados:

Considere a implementação de um programa que utiliza estruturas de uma fila de inteiros (F) e de uma pilha de inteiros (P), além de uma varável inteira (V). Trata-se do processamento de uma sequência de inteiros, que segue duas regras: se o atual elemento da sequência é maior que V, então movemos um elemento de P para F, descartamos um elemento de F, inserimos o valor de V também em F e atribuímos a V o atual elemento da sequência. Caso contrário, descartamos um elemento de P, movemos um elemento de F para P, inserimos o valor de V em P e atribuímos a V o atual elemento da sequência. Considerando que, no início, temos F={3,4,8}, P={2,1,5}, sendo que, para ambas, a ordem dessas listas é do mais antigo para o mais novo, e V=6, assinale a alternativa que apresenta o estado final de F e P após o programa receber a sequência de inteiros 7,9,4,3.

Julgue cada afirmativa abaixo sobre listas ordenadas, listas encadeadas, pilhas e filas como verdadeira (V) ou falsa (F). Em seguida, assinale a opção que corresponde à sequência CORRETA:

( ) Em uma lista encadeada simples, a inserção de um novo elemento no final da lista sempre requer tempo constante O(1).

( ) Em uma pilha, a operação de remoção de um elemento segue o princípio FIFO (First In, First Out).

( ) Em uma fila, a operação de inserção e remoção de elementos pode ser realizada em qualquer posição da estrutura, desde que seja mantida a ordenação.

( ) Em uma lista ordenada, a inserção de um novo elemento sempre ocorre em tempo O(1), independentemente de sua posição.

( ) Em uma fila, a operação de inserção ocorre no final da estrutura, enquanto a remoção ocorre no início, seguindo o princípio FIFO.

Considere os códigos a seguir:

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.

Na programação de sub-rotinas em linguagem assembly, é comum o armazenamento temporário de dados e/ou de endereços, para que sejam restaurados logo após o retorno à função principal. As pilhas (stacks) são estruturas de dados do tipo LIFO (Last In, First Out) adequadas para armazenar dados e/ou endereços quando alguma sub-rotina é chamada. Os conjuntos de instruções das arquiteturas mais comumente utilizadas possuem instruções específicas de acesso à pilha.

Na arquitetura 8051, as instruções usadas para retirar dados da pilha e para armazenar dados na pilha, colocando-os em registradores de uso geral, são, respectivamente,

Pilhas são tipos de estruturas de dados que permitem a remoção direta de qualquer elemento de sua estrutura.

A estrutura de dados utilizada pelas linguagens de programação em que o elemento removido da estrutura é o que foi inserido mais recentemente é chamada de

“A pilha implementa o conceito de Primeiro a Entrar será o Último a Sair. O último elemento a ser inserido na pilha é o primeiro a ser removido, enquanto o primeiro a ser inserido é o último que sai”. Baseado na afirmativa sobre estrutura de dados, assinale a alternativa que contém na sigla correta para a afirmativa: