| Ref.:
201402621151 |
|
 |
 2a Questão |
|
|
| Caso uma estrutura homogênea (vetor) seja passada como parâmetro para uma função, então: |
|
|
|
Essa passagem é "por referência" |
|
|
Essa passagem pode ser "por valor" ou "por referência" |
|
|
Essa passagem é "por valor" |
|
Todos os valores contidos no vetor são copiados para a função |
|
|
Haverá um erro de compilação, pois vetores não podem ser parâmetros de funções |
Explicação: Quando
o vetor é um parâmetro de uma função ele é sempre passado por
referência, não havendo outra possibilidade. Não ocorrerá erro, se o
vetor for devidamente passado para a função. |
|
| Ref.:
201401551517 |
|
|
 3a Questão |
|
|
Assinale a opção certa.
Quando não se escreve o protótipo de uma função ... |
|
|
|
|
A definição da função deverá ser escrita, obrigatoriamente, após o programa principal. |
|
|
A chamada da função não poderá ser feita em qualquer hipótese. |
|
|
A chamada da função poderá ser feita em qualquer hipótese. |
|
|
O programa não funcionará de forma alguma. |
|
|
É preciso definir a função antes do programa principal. |
|
| Ref.:
201402097905 |
|
|
| 4a Questão |
|
|
| Blocos
únicos de códigos que realizam diversas tarefas distintas são de
difícil manutenção. Portanto, utiliza-se a técnica da modularização de
programas, a fim de facilitar a implementação e a manutenção dos
programas. Esta técnica tem como principal elemento:
|
|
|
|
|
As Estruturas de Dados
|
|
|
Os Grafos
|
|
|
As Filas
|
|
|
Os Vetores
|
|
|
As funções
|
|
| Ref.:
201401484384 |
|
|
| 5a Questão |
|
|
| Em
programação podemos utilizar um recurso que modulariza o programa
chamado função. As funções precisam ser ativadas para que possam ser
executadas. Para isso, é necessário chamar a função pelo seu nome e
enviar, quando necessário, os valores respectivos para os parâmetros de
entrada. Ao enviar os valores para os parâmetros de entrada, o programa
pode fazer uma cópia deste valor ou trabalhar em um endereço enviado.
Quando se envia o endereço estamos ativando a função por meio de: |
|
|
|
|
Registro. |
|
|
Envio de valor. |
|
|
Ponteiros. |
|
|
Envio de inteiro. |
|
|
Passagem por valor. |
Explicação:
| Falso. Quando se tem endereço não é passagem por valor |
Passagem por valor. |
|
| FAlso. Fala-se em endereço do valor |
Envio de inteiro. |
|
 Verdadeiro. Ponteiro armazena o endereço de memória de uma variável |
Ponteiros. |
|
| Falso. Como é esse envio ? |
Envio de valor. |
|
| FAlso. Sem sentido. Resgistro (struct em C++) agrega dados de tipos diferentes. |
Registro. |
|
|
| Ref.:
201401717358 |
|
|
| 6a Questão |
|
|
Informe qual deverá ser a saída do programa abaixo:
#include
void func(int *x)
{
do{
cout << *x << " ";
(*x)--;
}while(*x>0);
}
main()
{
int x=5;
func(&x);
cout << x;
system("pause");
}
|
|
|
|
|
5 3 4 2 1 0 |
|
|
5 4 3 2 1 6 |
|
|
5 3 4 2 1 4 |
|
|
5 4 3 2 1 0 |
|
|
5 4 3 2 1 5 |
|
| Ref.:
201402358498 |
|
|
| 7a Questão |
|
|
| Sobre funções, é correto afirmar: |
|
|
|
|
Não podem ser chamadas dentro de outras funções. |
|
|
São blocos de instruções que são executados quando são chamadas em alguma parte do programa.
|
|
|
Obrigatoriamente devem possuir parâmetros. |
|
|
Obrigatoriamente devem retornam algum valor. |
|
|
Não devem conter variáveis locais em seu código. |
Explicação: Uma
função é um bloco de instruções que pode ser chamada a partir de outra
função, que pode ter ou não parâmetros, que pode ou não retornar valor,
que pode ter ou não variáveis locais. |
|
| Ref.:
201402141493 |
|
|
| 8a Questão |
|
|
| Funções
são semelhantes aos procedimentos, exceto que uma função sempre retorna
um valor.
Um exemplo de função seria o conjunto de instruções para calcular o
fatorial de um número e após
a função ser executada, ela deve retornar o fatorial do número pedido.
Marque a opção que representa um protótipo de função válido. |
|
|
|
|
tipo parametros(parametros); |
|
|
void float(int a, int b); |
|
|
nome tipo(parametros); |
|
|
retorno nomeFuncao(parametros); |
|
|
tipo parametros(int a, int b); |
|
Considere as seguintes afirmativas :
I) Os vetores em C++, quando passados como parâmetros de funções,
são obrigatoriamente passados "por valor" e não "por referência".
II) Variáveis globais são um recurso adequado para troca de informações entre funções distintas.
III) Caso uma função necessite retornar mais de um valor ao programa
que a chamou, deve fazê-lo usando parâmetros passados "por valor".
As afirmativas corretas são: |
|
|
|
|
Apenas I e II |
|
|
Apenas I |
|
|
Apenas II |
|
|
Nenhuma está correta |
|
|
Apenas III |
| Ref.:
201401483845 |
|
|
| 1a Questão |
|
|
| Qual das seguintes estruturas de dados é classificada como heterogênea? |
|
|
|
|
Loop |
|
|
Registro
|
|
|
Vetor |
|
|
Pilha |
|
|
Fila |
Explicação: Registro permite agregar dados de tipos diferentes.
Vetor permite agregar dados do mesmo tipo.
Pilha e fila implementadas com vetor ou lista encadeada.
Loop : termo genérico para repetições. |
|
| Ref.:
201401689060 |
|
|
| 2a Questão |
|
|
Com relação à struct, é correto afirmar que :
|
|
|
|
|
Não é possível criar um vetor de structs, pois o vetor trabalha apenas com dados do mesmo tipo.
|
|
|
Cada elemento da struct é chamado componente.
|
|
|
A struct é sempre definida dentro da main.
|
|
|
Cada elemento da struct é chamado campo e cada campo deve ser, obrigatoriamente, de um tipo de dados distinto de outro campo.
|
|
|
Cada elemento da struct é denominado membro ou campo, sendo que a struct pode armazenar elementos de tipos diferentes ou não.
|
|
| Ref.:
201401484019 |
|
|
| 3a Questão |
|
|
| Marque a afirmativa correta para a "Inserção em lista linear sequencial ordenada".
|
|
|
|
|
É o processo pelo qual um conjunto de dados é colocado em uma ordem crescente ou decrescente.
|
|
|
Consiste em adicionar um valor no vetor, mantendo a ordem existente e ajustando o total de elementos.
|
|
|
Consiste em adicionar um valor no vetor, alterando a ordem existente e ajustando o total de elementos.
|
|
|
Consiste
em fazer uma busca em um vetor desordenado, dividindo o espaço de busca
ao meio e verificando se o dado está no meio ou, antes do meio ou
depois do meio.
|
|
|
Consiste
em fazer uma busca em um vetor já ordenado, dividindo o espaço de busca
ao meio e verificando se o dado está no meio ou, antes do meio ou
depois do meio.
|
Explicação: Consiste em adicionar um valor no vetor, mantendo a ordem existente e ajustando o total de elementos.
Só pode ocorrer, no entanto, se a lista não estiver cheia. |
|
| Ref.:
201402054221 |
|
|
| 4a Questão |
|
|
| Pode-se
definir uma estrutura heterogênea como sendo um conjunto de elementos,
geralmente, agrupados sob uma lógica e associados por um nome.
Esses elementos podem ser variáveis simples, matrizes ou ainda outras
estruturas. Seja a definição de uma estrutura como:
struct aluno {
string nome;
float media;
};
Suponha ainda que exista um vetor desta estrutura, definido como:
aluno vet [ 10];
Marque a alternativa em que é atribuída de forma correta a media 6.0
para o quarto elemento deste vetor.
|
|
|
|
|
vet[3].aluno=6.0; |
|
|
aluno[3].10=6.0; |
|
|
aluno[10]=6.0; |
|
|
vet[3].media=6.0; |
|
|
aluno[3].media=6.0; |
|
| Ref.:
201402155949 |
|
|
| 5a Questão |
|
|
Marque a opção correta, considerando
struct Livro {
int codigo;
float preco;
} liv; |
|
|
|
|
Livro.codigo = 12345; |
|
|
liv.preco = 30.70; |
|
|
liv->preco = 30.70; |
|
|
Livro->liv.codigo = 12345; |
|
|
Livro.liv.codigo = 12345; |
|
| Ref.:
201402097910 |
|
|
| 6a Questão |
|
|
Pode-se
definir uma estrutura heterogênea como sendo um conjunto de elementos,
geralmente, agrupados sob uma lógica e associados por um nome.
Esses elementos podem ser variáveis simples, matrizes ou ainda outras estruturas. Seja a definição de uma estrutura como:
struct aluno {
string nome;
float nota;
};
Suponha ainda que exista um vetor desta estrutura, definido como:
aluno vet [100];
Marque a alternativa em que é atribuída de forma correta a nota 5.7 para o décimo primeiro elemento deste vetor. |
|
|
|
|
vet[10]=aluno.5.7;
|
|
|
vet[10].aluno.nota=5.7 ;
|
|
|
vet[10].nota=5.7;
|
|
|
aluno.vet[10]=5.7;
|
|
|
aluno.vet[10].nota=5.7; |
|
| Ref.:
201402526926 |
|
|
| 7a Questão |
|
|
Dadas as afirmativas abaixo, identifique as corretas e marque a alternativa verdadeira.
I- Vetores e matrizes servem apenas para construir agregados de dados heterogêneos.
II- Registros em C++ são tipos de dados compostos formados por mais de um tipo de dados.
III- Na Linguagem C++, "struct" é uma palavra reservada que serve para definir registros.
IV- Registros são tipos de dados heterogêneos. |
|
|
|
|
estão corretas apenas as afirmativas II, III e IV. |
|
|
estão corretas apenas as afirmativas I, II e III. |
|
|
todas as afirmativas estão corretas. |
|
|
estão corretas apenas as afirmativas I, III e IV. |
|
|
estão corretas apenas as afirmativas I, II e IV. |
Explicação: Analisando as afirmativas, temos :
Afirmativa I : Falso. Vetores e matrizes são agregados homogêneos.
Afirmativas II, III e IV : Estão corretas. Basicamente, structs são agregados heterogêneos.
Logo, a opção correta é estão corretas apenas as afirmativas II, III e IV. |
|
| Ref.:
201402208793 |
|
|
| 8a Questão |
|
|
| o
programa de computador necessita preencher uma lista de alunos (nome e
nota) até que a lista esteja cheia. Sabe-se que a lista tem capacidade
para 25 alunos. Utilizando agregados heterogêneos, qual o trecho de
código que exibe a melhor forma de solucionar este problema? |
|
|
|
|
for (int i = 0; i <= 25; i++) {
cin >> lista[i].nome;
cin >> lista[i].nota;
} |
|
|
for (int i = 0; i < 25; i++) {
cin >> lista->nome;
cin >> lista->nota;
} |
|
|
for (int i = 0; i < 25; i++) {
cin >> lista[i].nome;
cin >> lista[i].nota;
} |
|
|
int i = 0;
while( i < 25) {
cin >> lista[i].nome;
cin >> lista[i].cargo;
i ++;
}
|
|
|
for (int i = 0; i < 25; i++) {
cin >> lista[i]->nome;
cin >> lista[i]->nota;
} |
|
|
| Ref.:
201402054212 |
|
|
| 1a Questão |
|
|
 |
|
|
|
|
if(vet[j-1] > vet[j] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
|
|
|
if(vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j-1]= vet[j];
vet[j-1]=aux;
}
|
|
|
if(vet[j-1] < vet[j] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
|
|
|
if(vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]< vet[j-1];
vet[j-1]=aux;
}
|
|
|
if(vet[j] == vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
|
|
| Ref.:
201401487417 |
|
|
| 2a Questão |
|
|
| Existem
vários algoritmos de busca em estruturas de dados, um destes realiza a
busca em vetores, e requer acesso aleatório aos elementos desta
estrutura e parte do pressuposto de que os dados do vetor estejam
ordenados e utiliza a técnica de divisão e conquista comparando o
elemento desejado com o elemento do meio do vetor. Esta técnica ainda
verifica se o elemento do meio do vetor for o desejado, a busca termina.
Caso contrário, se o elemento do meio vier antes do elemento buscado,
então a busca continua na metade posterior do vetor. E se o elemento do
meio vier depois da chave, a busca continua na metade anterior do vetor.
O algoritmo que utiliza esta metodologia é: |
|
|
|
|
Bolha |
|
|
Inserção |
|
|
Pesquisa sequencial |
|
|
Pesquisa binária |
|
|
Seleção |
|
| Ref.:
201401484380 |
|
|
| 3a Questão |
|
|
| Os
algoritmos de busca são muito utilizados em estrutura de dados. Sendo
assim, o algoritmo que realiza a busca em vetores e que exige acesso
aleatório aos elementos do mesmo e que parte do pressuposto de que o
vetor está ordenado e realiza sucessivas divisões do espaço de busca
comparando o elemento que se deseja com o elemento do meio do vetor, é
chamado de: |
|
|
|
|
Pesquisa sequêncial |
|
|
Pesquisa binária |
|
|
Pesquisa ordenada |
|
|
Tabela Hash |
|
|
Pesquisa de seleção |
Explicação: O enunciado descreve a busca binária.
A busca sequencial trabalha sequencialmente testando elemento a elemento.
Pesquisa de seleção ou ordenada não foram abordadas.
Tabela hash trabalha com função hash e não se encaixa na descrição feita. |
|
| Ref.:
201402325261 |
|
|
| 4a Questão |
|
|
| Ref.:
201402318752 |
|
|
| 5a Questão |
|
|
| Qual característica NÃO podemos atribuir a PESQUISA BINÁRIA. |
|
|
|
|
A lista pode estar desordenada. |
|
|
São realizadas sucessivas divisões da lista ao meio. |
|
|
Quando o valor pesquisado é maior do que a chave do MEIO da lista, devemos dispensar a metade que vem antes do meio da lista. |
|
|
A lista precisa estar ordenada. |
|
|
É eficiente quando se trata de listas ordenadas |
Explicação: Na pesquisa binária a lista obrigatoriamente deverá estar ORDENADA. |
|
| Ref.:
201401484024 |
|
|
| 6a Questão |
|
|
| Marque a afirmativa correta para a "Busca ou pesquisa binária".
|
|
|
|
|
Consiste em adicionar um valor no vetor, alterando a ordem existente e ajustando o total de elementos.
|
|
|
Consiste
em fazer uma busca em um vetor desordenado, dividindo o espaço de busca
ao meio e verificando se o dado está no meio ou, antes do meio ou
depois do meio.
|
|
|
Consiste
em fazer uma busca em um vetor já ordenado, dividindo o espaço de busca
ao meio e verificando se o dado está no meio ou, antes do meio ou
depois do meio.
|
|
|
É o processo pelo qual um conjunto de dados é colocado em uma ordem crescente ou decrescente.
|
|
|
Consiste em adicionar um valor no vetor, mantendo a ordem existente e ajustando o total de elementos.
|
|
| Ref.:
201402047443 |
|
|
| 7a Questão |
|
|
Estude atentamente o código a segir:
int deciframe(int v[ ], int tam, int e){
int i = 0, f = tam -1, m;
while ( i <= f ){
m = ( i + f ) / 2;
if ( v[m] == e ) { return m; }
if ( e < v[m] ) { f = m - 1; }
else { i = m + 1; }
}
return -1;
}
Sabendo que a chamada da mesma foi feita com os parâmetros recebendo os seguintes valores, o que ela retornaria?
v[10] = {0, 2, 4, 6, 8, 10, 20, 100}
tam = 8
e = 0 |
|
|
|
|
2 |
|
|
0 |
|
|
1 |
|
|
-1 |
|
|
-2 |
Explicação: A
busca pode retornar o índice do elemento encontrado ou pode retornar
-1, caso o elemento e não seja encontrado. Vemos que o valor de e é encontrado. Logo, a função retornará a posição do valor e = 0 no vetor. No caso, o elemento zero está na posição 0.
Resposta : 0 |
|
| Ref.:
201402072651 |
|
|
| 8a Questão |
|
|
| Sabendo-se
que o método de seleção também é um método de ordenação que baseia seu
algoritmo em trocas entre os elementos de um vetor, se submetermos a
sequencia de inteiros armazenada em um vetor inicialmente na seguinte
ordem : 13, 23, 3, 8, 1. Pode-se dizer que quando o menor elemento do
vetor alcançar sua posição final, a ordenação apresentada no vetor é: |
|
|
|
|
1,13,23,8,3
|
|
|
1,23,3,8,13
|
|
|
1,23,13,8,3
|
|
|
1,3,23,8,13 |
|
|
1,8,3,23,13
|
|
|
|
| Ref.:
201402048075 |
|
|
| 1a Questão |
|
|
| __________________________
é uma lista linear em que a alocação de memória pode ser estática, e
que a forma de armazenamento é contígua ou sequencial na memória. Usamos
este tipo de lista quando se tem em mente um tamanho pré-definido, ou
seja, quando se sabe até onde a lista pode crescer. |
|
|
|
|
Lista Não Linear |
|
|
Lista Linear de Alocação de Memória |
|
|
Lista Linear Não Alocada |
|
|
Lista Linear Não Sequencial |
|
|
Lista Linear Sequencial |
|
| Ref.:
201401686625 |
|
|
| 2a Questão |
|
|
| Ref.:
201402539535 |
|
|
| 3a Questão |
|
|
Analise a função abaixo, considerando o tipo Livro e marque a opção correta.
int R2D2 (Livro v[ ], int c, int n) {
for (int i = 0; i < n; i++)
if (v[i].codigo == c)
return i;
return -1;
}
onde
struct Livro {
int codigo;
char autor[30];
}; |
|
|
|
|
Retorna -1 se o valor de n foi encontrado. |
|
|
Ocorre erro na função R2D2 se o valor de c não estiver sido encontrado em v. |
|
|
Retorna a posição do valor c em v , se o valor c for encontrado em v. |
|
|
Retorna o valor de c se o valor n foi encontrado. |
|
|
Retorna -1 se o valor de c estiver em v. |
Explicação: Questão objetiva. A função realiza uma busca sequencial.
A cada rodada do loop é verificado se o código de v[i] é igual ao
valor de c, passado como parâmetro. Se o código estiver em v[i], então a
posição i é retornada. Se o teste do if nunca tiver sucesso, então,
sairemos do for sem sucesso e ao final, será retornado -1, que não pode
ser índice ou posição de qualquer valor no vetor. |
|
| Ref.:
201401484208 |
|
|
| 4a Questão |
|
|
| Ref.:
201402521013 |
|
|
| 5a Questão |
|
|
Em relação às listas sequenciais, considere as seguintes afirmações:
I - são estruturas lineares que utilizam vetores para armazenamento dos dados;
II - os componentes da lista são os dados que se deseja armazenar e um valor inteiro com a quantidade de dados da lista;
III - os dados são sempre inseridos ou removidos no final da lista,
tomando-se sempre o cuidado de atualizar a quantidade de dados da lista;
IV - listas podem apresentar dados repetidos ou não admitir repetição (listas com e sem repetição).
Assinale a opção que contém apenas todas as afirmativas corretas: |
|
|
|
|
I, II, III |
|
|
I, II, III, IV |
|
|
I, II |
|
|
II, III, IV |
|
|
I, II, IV |
Explicação: Analisando cada afirmativa :
I - são estruturas lineares que utilizam vetores para armazenamento dos dados;
Verdadeira. O vetor é sequencial e tem tamanho pré-definido.
II - os componentes da lista são os dados que se deseja armazenar e um valor inteiro com a quantidade de dados da lista;
Verdadeira.
III - os dados são sempre inseridos ou removidos no final da lista,
tomando-se sempre o cuidado de atualizar a quantidade de dados da lista;
Falso, pois é possível inserirmos em qualquer posição da lista.
IV - listas podem apresentar dados repetidos ou não admitir repetição (listas com e sem repetição).
Verdadeiro.
Logo, as afirmativas I, II e IV estão corretas |
|
| Ref.:
201402131894 |
|
|
| 6a Questão |
|
|
Considere uma lista com n livros, em que cada livro é modelado pela struct :
struct Livro {
string titulo, editora, autor;
float preco;
};
A função X abaixo
void X (Livro v[ ], int &n, Livro L)
{
v[n] = L;
n++;
cout << "Operação realizada com sucesso.";
}
implementa a operação de :
|
|
|
|
|
Substituição
|
|
|
Inicialização |
|
|
Busca |
|
|
Inserção
|
|
|
Ordenação por inserção |
|
| Ref.:
201401551487 |
|
|
| 7a Questão |
|
|
| São métodos ou algoritmos conhecidos de ordenação de dados por troca: |
|
|
|
|
quicksort e hashing. |
|
|
ordenação shell e hashing. |
|
|
hashing e bubble sort. |
|
|
bubble sort e quicksort. |
|
|
busca por ordenação e ordenação shell. |
Explicação: Bubble sort é
o algoritmo mais simples, mas o menos eficientes. Neste algoritmo cada
elemento da posição i será comparado com o elemento da posição i + 1, ou
seja, um elemento da posição 2 será comparado com o elemento da posição
3. Caso o elemento da posição 2 for maior que o da posição 3, eles
trocam de lugar e assim sucessivamente. Por causa dessa forma de
execução, o vetor terá que ser percorrido quantas vezes que for
necessária, tornando o algoritmo ineficiente para listas muito grandes.
O Quicksort é o algoritmo mais eficiente na
ordenação por comparação. Nele se escolhe um elemento chamado de pivô, a
partir disto é organizada a lista para que todos os números anteriores a
ele sejam menores que ele, e todos os números posteriores a ele sejam
maiores que ele. Ao final desse processo o número pivô já está em sua
posição final. Os dois grupos desordenados recursivamente sofreram o
mesmo processo até que a lista esteja ordenada.
|
|
| Ref.:
201402606601 |
|
|
| 8a Questão |
|
|
| Considere as seguintes afirmações:
I. Só podemos ter uma matriz de no máximo duas dimensões. Exemplo: C[100][100].
II. Ao declararmos um vetor int A[10], se escrevemos A[2] acessamos o segundo elemento do vetor.
III. Uma string declarada como char B[30] armazena no máximo 30 caracteres.
Escolha a alternativa correta:
|
|
|
|
|
Nenhuma afirmação está correta. |
|
|
Estão corretas apenas as afirmativas I e III. |
|
|
Estão corretas apenas as afirmativas I e II. |
|
|
Está correta apenas a afirmativa I. |
|
|
Está correta apenas a afirmativa II. | | |
| Ref.:
201401487184 |
|
|
| 1a Questão |
|
|
| Quando
executado, um programa tem acesso à áreas de memória. A área de memória
que se destina, principalmente, à alocação dos registros de ativação
denomina-se:
|
|
|
|
|
( ) área de pilha |
|
|
( ) área de dados |
|
|
( ) área de código |
|
|
( ) área de heap |
|
|
( ) área de registro |
Explicação: Chamamos
área de pilha uma espaço de memória especialmente reservado para
organização de uma pilha de dados. Esta pilha é usada como memória
auxiliar durante a execução de uma aplicação.
As operações sobre esta área são push (empilha) e pop (desempilha). |
|
| Ref.:
201402556702 |
|
|
| 2a Questão |
|
|
Observar os quadros abaixo e reponder o que se pede:
O que aparecerá no topo da PILHA apos os comandos do quadro II? |
|
|
|
|
SANTO_ESPEDITO |
|
|
SANTO_ANTONIO |
|
|
SANTA_CATARINA |
|
|
SANTA_GENOVEVA |
|
|
SANTOS_AGOSTINHO |
Explicação: FAzendo passo a passo...
empilha SANTO_ANTONIO e depois, SANTA_FILOMENA. Fica SANTA_FILOMENA no topo.
No item c) desempilha. Então, sai SANTA_FILOMENA da pilha.
No item d) empilha SANTO_AGOSTINHO. Então, fica SANTO_ANTONIO e logo no topo, SANTO_AGOSTINHO.
No item e) temos o elemento do topo que é SANTO_AGOSTINHO.
No item f) empilhamos SANTA_CATARINA. Então, a sequência
é SANTO_ANTONIO -> SANTO_AGOSTINHO - >SANTA_CATARINA (NO TOPO DA
PILHA)
No item g, destaca-se o elemento do topo que é SANTA_CATARINA.
No item h) empilha-se SANTO_EXPEDITO . Então, a pilha fica assim
: SANTO_ANTONIO -> SANTO_AGOSTINHO - >SANTA_CATARINA
-> SANTO_EXPEDITO (este último no topo da pilha).
No item i) Desempilha-se o item do topo, ou seja, SANTO_EXPEDITO.
Então, a pilha fica assim : SANTO_ANTONIO -> SANTO_AGOSTINHO -
>SANTA_CATARINA
No item j) empilha-se o valor do topo . Então, a pilha fica assim :
SANTO_ANTONIO -> SANTO_AGOSTINHO - >SANTA_CATARINA -> SANTA_CATARINA
No item k) Desempilha-se um valor e este valor é empilhado. Sai SANTA_CATARINA, mas o mesmo é empilhado. Então :
SANTO_ANTONIO -> SANTO_AGOSTINHO - >SANTA_CATARINA -> SANTA_CATARINA (no topo)
No item l) empilha-se SANTA_GENOVEVA. Então, a pilha fica assim
: SANTO_ANTONIO -> SANTO_AGOSTINHO - >SANTA_CATARINA
-> SANTA_CATARINA -> SANTA_GENOVEVA
No item m) É desempilhado SANTA_GENOVEVA. A pilha fica
: SANTO_ANTONIO -> SANTO_AGOSTINHO - >SANTA_CATARINA
-> SANTA_CATARINA
No item n) Pega-se o elemento do topo e o mesmo é empilhado. Então :
ANTO_ANTONIO -> SANTO_AGOSTINHO - >SANTA_CATARINA -> SANTA_CATARINA - > SANTA_CATARINA (no topo)
Logo, no topo da pilha temos SANTA_CATARINA
|
|
| Ref.:
201404280270 |
|
|
| 3a Questão |
|
|
| A
estrutura de dados linear que obedece o seguinte critério: o último
elemento inserido será o primeiro elemento a ser retirado (LIFO) é: |
|
|
|
|
Fila |
|
|
Pilha |
|
|
Lista circular |
|
|
Árvore binária |
|
|
Árvore AVL |
Explicação:
Por
definição, a estrutura de dados pilha segue a lógica LIFO (Last In
First Out), em que o último a entrar será o primeiro a sair. Portanto, a
opção correta é pilha.
Fila : Lista linear em que segue-se a lógica FIFO (First In First Out) para inserções e remoções.
Árvore binária : pode ser ordenada ou não. Se não for, insere-se em qualquer posição e o mesmo para remoção.
Árvore AVL : Insere-se e retira-se de forma ordenada
Lista circular : Pode-se inserir ou remover de qualquer nó da lista.
|
|
| Ref.:
201402476808 |
|
|
| 4a Questão |
|
|
| Sobre as pilhas, marque a alternativa correta: |
|
|
|
|
Pilhas são estruturas de dados do tipo FIFO e permitem que os dados sejam manipulados diretamente no meio da estrutura. |
|
|
A
característica principal que define uma Pilha diz respeito às operações
de inserção e remoção, que devem ser realizadas exclusivamente na mesma
extremidade. |
|
|
Pilhas
não podem ser implementadas usando vetores, pois não será possível
reproduzir a inserção e remoção pela mesma extremidade. |
|
|
A
operação de desempilhar um item de uma pilha e logo em seguida
empilha-lo em outra pilha mantem a mesma ordem dos dados da primeira
pilha na segunda pilha. |
|
|
Pilhas
são menos restritivas do que Listas, pois esta última impõe mais
restrições às operações de inserção/remoção do que as primeiras. |
Explicação: Analisando cada item.
|
|
| Ref.:
201402046877 |
|
|
| 5a Questão |
|
|
| Ref.:
201401475904 |
|
|
| 6a Questão |
|
|
| Seja
S uma pilha inicialmente vazia. Primeiramente, o elemento A é inserido
em S. Em seguida, o elemento B, e assim por diante, até a inclusão final
do elemento E. Ao término dessas operações, qual elemento estará no
topo de S? |
|
|
|
|
C. |
|
|
E. |
|
|
B. |
|
|
D. |
|
|
A. |
Explicação: O
último elemento a entrar foi o E, portanto tal elemento está no topo da
pilha. Pilha segue a lógica LIFO. Insere-se no topo e retira-se do
topo. |
|
| Ref.:
201404280294 |
|
|
| 7a Questão |
|
|
Algoritmo Pilha
Inicio
IniciarPilha(s)
enquanto (não for o final das entradas) faca
leia (num)
se (num != 3) então
Empilhar (s, num)
senão
Desempilhar(s)
x := ElementoTopo(s)
fimse
fimenquanto
fimalgoritmo
Considere que, no trecho do algoritmo acima, representado por seu pseudocódigo, seja fornecido para num, sucessivamente, os valores inteiros 1, 2, 3, 4, 5, 3 e 6. Nesse caso, ao final da execução do algoritmo, o valor de x será igual a ... |
|
|
|
|
2 e a pilha terá os valores 6, 4 e 1. |
|
|
5 e a pilha terá os valores 6, 4 e 1. |
|
|
3 e a pilha terá os valores 6, 5, 4, 2 e 1. |
|
|
5 e a pilha terá os valores 6, 3, 5, 4, 3, 2 e 1. |
|
|
3 e a pilha terá os valores 6, 4 e 1. |
Explicação: Seguindo o fluxo do algoritmo, serão empilhados 1 e 2. Ao chegar no 3, o valor 2 será desempilhado e armazenado em x.
Continuando o loop, 4 é mepilhado, depois 5 é empilhado e ao chegar
novamente em 3, o 5 é deempilhado e armazenado em x. Continuando o loop
enquanto existe entrada, empilha-se o 6.
Dessa forma temos que o valor em 5 é 5 e a pilha possui os valors 6, 4 e 1, sendo 6 no topo da pilha.
Logo, a opção correta é 5 e a pilha terá os valores 6, 4 e 1. |
|
| Ref.:
201401551480 |
|
|
| 8a Questão |
|
|
| A técnica LIFO, utilizada em programação estruturada, é fundamentada no conceito de: |
|
|
|
|
Array. |
|
|
Loop. |
|
|
Ponteiro. |
|
|
Fila. |
|
|
Pilha. |
|
|
| Ref.:
201402075352 |
|
|
| 1a Questão |
|
|
Considere uma fila simples F de inteiros, do
tipo Fila definido abaixo. Tal fila deverá armazenar códigos de agentes
de uma firma de espionagem, desde que haja espaço para um novo agente. Assinale
a opção que corretamente desenfileira o código de um agente, sabendo
que a fila F foi inicializada de acordo com o trecho de código abaixo.
struct Fila { in t v[100], inicio, fim; } ;
Fila F;
F. inicio = 0;
F.fim = -1;
|
|
|
|
|
void desenfileirar(Fila F) {
cout << "Removido o agente " << F.v[F.inicio];
F.inicio--;
}
|
|
|
void desenfileirar(Fila &F) {
if (F.inicio > F.fim)
cout << "Não há agentes para retirar. " << endl;
else {
cout << "Removido o agente " << F.v[F.inicio];
F.inicio++;
}
}
|
|
|
void desenfileirar(Fila &F) {
if (F.fim == -1 && F.inicio == 0)
cout << "Não há agentes para retirar. " << endl;
else {
cout << "Removido o agente " << F.v[F.inicio];
F.inicio++;
}
}
|
|
|
void desenfileirar(Fila F) {
if (F.inicio > F.fim)
cout << "Não há agentes para retirar. " << endl;
else {
cout << "Removido o agente " << F.v[F.inicio];
F.inicio++;
}
}
|
|
|
void desenfileirar(Fila &F) {
if (F.inicio > F.fim)
cout << "Não há agentes para retirar. " << endl;
else {
cout << "Removido o agente " << F.v[F.inicio];
}
}
|
|
| Ref.:
201401483868 |
|
|
| 2a Questão |
|
|
Considere
uma estrutura de dados, representada pela variável P, com procedimentos
de inclusão, exclusão e consulta do próximo elemento (e) disponível na
estrutura, obedecendo às seguintes propriedades:
Pode-se concluir, então, que P corresponde à seguinte estrutura de dados? |
|
|
|
|
CONJUNTO |
|
|
PILHA |
|
|
STRUCT |
|
|
LISTA |
|
|
PONTEIRO |
Explicação: Pela estrutura apresentada verifica-se ser a de uma Pilha. |
|
| Ref.:
201401484329 |
|
|
| 3a Questão |
|
|
| Considerando
que uma fila seqüencial utiliza dois apontadores para indicar suas
posições de final e início da estrutura, supondo que a fila foi criada
com os apontadores apontando para a posição zero do vetor, qual das
alternativas a seguir pode caracterizar uma fila vazia? |
|
|
|
|
Quando o apontador de posição final for igual ao início. |
|
|
Quando o apontador de início apontar para zero. |
|
|
Quando o apontador de final menos um (final-1) for igual ao inicio. |
|
|
Quando os apontadores de final e início apontarem para zero. |
|
|
Quando o apontador de final apontar para zero. |
Explicação: Suponha que nossa fila mora em um vetor fila[0..N-1].
(A natureza dos elementos do vetor é irrelevante: eles podem ser
inteiros, bytes, ponteiros, etc.) Digamos que a parte do vetor ocupada
pela fila é
fila[p..u-1] .
O primeiro elemento da fila está na posição p e o último na posição u-1.
A fila está vazia se p == u e cheia se u == N.
|
|
| Ref.:
201401483842 |
|
|
| 4a Questão |
|
|
| Complete
os espaços na afirmativa abaixo e assinale a alternativa que apresenta
as respostas corretas:
O escalonamento .................... é do tipo.................., em que
o processo que chegar primeiro na fila de pronto é o escolhido para ser
executado.
|
|
|
|
|
FIFO, não-preemptivo. |
|
|
Por prioridades, preemptivo. |
|
|
LIFO, não-preemptivo. |
|
|
Circular, não-preemptivo. |
|
|
SJF (Shortest-Job-First), preemptivo. |
Explicação: O algoritmo de escalonamento FIFO (First in, first out, em português: "O primeiro a entrar é o primeiro a sair, sigla PEPS), ou FCFS(First come, first served,
em português: "O primeiro a chegar é o primeiro a ser servido") é
conhecido popularmente por Algoritmo de Fila Simples, é uma estrutura de
dados que apresenta o seguinte critério: O primeiro elemento a ser
retirado é o primeiro que tiver sido inserido, é
um algoritmo de escalonamento não preemptivo que entrega
a CPU os processos pela ordem de chegada. Ele executa o processo como um
todo do inicio ao fim não interrompendo o processo executado até ser
finalizado, então quando um novo processo chega e existe um ainda em
execução ele vai para uma fila de espera. Esta fila de espera nada mais é
do que uma fila que organiza os processos que chegam até eles serem
atendidos pela CPU.
Neste escalonamento todos os processos tendem a serem atendidos (por
isso evita o fenômeno do starvation) ao menos que um processo possua um
erro ou loop infinito. O loop infinito irá parar a máquina, pois com o
FIFO não terá como dar continuidade a execução dos processos que estão
aguardando na fila de espera.
O algoritmo FIFO não garante um tempo de resposta rápido pois é
extremamente sensível a ordem de chegada de cada processo e dos
antecessores (se existirem) e se processos que tendem a demorar mais
tempo chegarem primeiro o tempo médio de espera e o turnaround acabam
sendo aumentados. |
|
| Ref.:
201402069480 |
|
|
| 5a Questão |
|
|
| O que acontece quando se deseja inserir um elemento em uma FILA que já está cheia? |
|
|
|
|
Enqueue. |
|
|
Underflow. |
|
|
A inserção é feita sem problema. |
|
|
Overflow. |
|
|
Dequeue. |
|
| Ref.:
201401484353 |
|
|
| 6a Questão |
|
|
| As
estruturas de dados podem ser do tipo estática e dinâmica. As listas
são estruturas parecidas com vetores podendo ser do tipo dinâmica.
Entretanto, existem várias implementações de estruturas do tipo listas.
Dessa forma, a estrutura que para o acesso de um dado, este precisa
estar na saída, caso contrário, precisa remover os elementos a sua
frente, é chamada de: |
|
|
|
|
Bolha |
|
|
Pilha |
|
|
Fila |
|
|
Matriz |
|
|
Struct |
|
| Ref.:
201402075314 |
|
|
| 7a Questão |
|
|
Considere uma fila simples F de inteiros, do
tipo Fila definido abaixo. Tal fila deverá armazenar códigos de agentes
de uma firma de espionagem, desde que haja espaço para um novo agente. Assinale
a opção que corretamente enfileira o código de um agente, sabendo que a
fila F foi inicializada de acordo com o trecho de código abaixo.
struct Fila { in t v[100], inicio, fim; } ;
Fila F;
F. inicio = 0;
F.fim = -1;
|
|
|
|
|
void enfileirar(Fila &F, int codigo) {
if (F.fim == 99)
cout << "Não há espaço na firma para mais agentes. " << endl;
else {
F.fim++;
F.v[F.fim] = codigo;
}
}
|
|
|
void enfileirar(Fila &F, int codigo) {
F.v[F.fim] = codigo;
F.fim++;
}
|
|
|
void enfileirar(Fila F, int codigo) {
F.fim++;
F.v[F.fim] = codigo;
}
|
|
|
void enfileirar(Fila &F, int codigo) {
if (F.fim == 99)
cout << "Não há espaço na firma para mais agentes. " << endl;
else
F.fim++;
F.v[F.fim] = codigo;
}
|
|
|
void enfileirar(Fila F, int codigo) {
if (F.fim == 100)
cout << "Não há espaço na firma para mais agentes. " << endl;
else {
F.fim++;
F.v[F.fim] = codigo;
}
}
|
|
| Ref.:
201401484167 |
|
|
| 8a Questão |
|
|
| Marque a afirmativa que represente uma Lista Circular Simplesmente Encadeada:
|
|
|
|
|
O ponteiro do "último" nó não é NULL, mas sim aponta de volta para o "primeiro" nó da lista.
|
|
|
Além do campo relativo ao dado, cada nó possui dois ponteiros,
|
|
|
Cada ponteiro possui um só endereço que referencia o "primeiro" nó da lista.
|
|
|
Cada nó possui um só ponteiro que referencia o próximo nó da lista.
|
|
|
O ponteiro do "primeiro" nó não é NULL, mas sim aponta de volta para o "último" nó da lista, formando um ciclo.
|
| Ref.:
201402526925 |
|
|
| 1a Questão |
|
|
| Ref.:
201402210538 |
|
|
| 2a Questão |
|
|
Verifique as afirmativas e marque a opção correta.
I- Na alocação estática de memória a quantidade de memória alocada é feita em tempo de compilação.
II- Na alocação dinâmica de memória a quantidade de memória alocada é feita em tempo de execução.
III- Na alocação estática de memória a quantidade de memória alocada é fixa durante a execução do programa.
IV- Na alocação dinâmica de memória a quantidade de memória alocada é fixa durante a execução do programa. |
|
|
|
|
Apenas a I está correta
|
|
|
Apenas a IV está errada
|
|
|
Apenas a opção I está errada |
|
|
Apenas as opções I e II são corretas
|
|
|
Apenas a II está correta
|
Explicação: Analisando cada afirmativa :
I- Na alocação estática de memória a quantidade de memória alocada é feita em tempo de compilação.
Correto. Aloca-se memória antes da execução.
II- Na alocação dinâmica de memória a quantidade de memória alocada é feita em tempo de execução.
Correto.
III- Na alocação estática de memória a quantidade de memória alocada é fixa durante a execução do programa.
Correto. A memória alocada antes da execução não sofre alteração durante a execução.
IV- Na alocação dinâmica de memória a quantidade de memória alocada é fixa durante a execução do programa.
Falso. A quantidade de memória não é fixa.
Apenas a afirmativa IV é falsa ou está errada. |
|
| Ref.:
201402075369 |
|
|
| 3a Questão |
|
|
Considere uma lista simplesmente encadeada com placas de carros. Assinale a opção que, corretamente, imprime todas as placas da lista. Considere :
struct no {
string placa;
struct no *link;
};
no *p; //p aponta para o início da lista
|
|
|
|
|
void imprimir(no *p) {
while (p != NULL) {
cout << pàplaca;
p = pàlink;
}
}
|
|
|
void imprimir(no *p) {
if (p != NULL) {
cout << pàplaca;
p = pàlink;
}
}
|
|
|
void imprimir(no p) {
while (p != NULL) {
cout << pàno;
p = pàlink;
}
}
|
|
|
void imprimir(no *p) {
while (p != NULL) {
cout << pàplaca;
}
}
|
|
|
void imprimir(no *p) {
while (p != NULL) {
cout << p.placa;
p = p.link;
}
}
|
|
| Ref.:
201401686644 |
|
|
| 4a Questão |
|
|
Seja uma lista encadeada cujo nodo é representado
por:
struct nodo{
int valor;
nodo prox;
};
Esta estrutura possui um ponteiro de referência que
aponta sempre para o primeiro nodo da lista, sendo este declarado como: nodo *lista;
Numa lista encadeada seu último nodo possui o campo prox
sempre igual a NULL. Marque a opção que representa o trecho de código onde um
ponteiro auxiliar é capaz de percorre a lista até seu último nodo:
|
|
|
|
|
nodo *aux=lista;
while(aux)aux->prox=aux; |
|
|
nodo *lista=aux;
while(aux->prox)aux=aux->prox; |
|
|
nodo *aux=lista;
while(lista->prox)aux=aux->prox; |
|
|
nodo *aux=lista;
while(aux->prox)aux=aux->prox; |
|
|
nodo *aux=lista;
while(aux->prox)aux->prox=aux->prox; |
Explicação: nodo *aux=lista;
while(aux->prox)aux=aux->prox; |
|
| Ref.:
201402209687 |
|
|
| 5a Questão |
|
|
| Qual o valor de x no final do programa?
int main() {
int x, *p, y;
x = 2;
p = &x;
y = *p;
y = 5;
(*p)++;
(*p) = (*p) - y;
return(0);
}
|
|
|
|
|
5 |
|
|
Nenhuma das anteriores. O programa possui um erro de sintaxe. |
|
|
8 |
|
|
2 |
|
|
-2 |
Explicação: Analisando passo a passo :
int main() {
int x, *p, y;
x = 2;
p = &x; // p aponta para x, sendo que x recebeu 2
y = *p; //y recebeu o conteúdo da área apontada por p, ou seja, y recebeu *p que é 2
y = 5; //y recebeu 5
(*p)++; //A área apontada por p recebeu 3 Ou seja, x recebeu 3
(*p) = (*p) - y; //*p, que é x recebeu 3 - 5. Ou seja, *p recebeu -2
return(0);
}
Como p aponta para x e *p recebeu -2, então x recebeu -2 |
|
| Ref.:
201401686634 |
|
|
| 6a Questão |
|
|
Seja uma lista encadeada cujos nodos são formados
pelo seguinte tipo de dado:
struct empregado{
long
int matricula;
float
salario;
empregado *proximo;
};
Suponha que o ponteiro pont
tenha o endereço de um nodo da lista, o qual se deseja atribuir um novo valor
para o campo salario. Marque a alternativa que corretamente altera o valor
do campo salario para 5000.00.
|
|
|
|
|
salario=5000.00; |
|
|
pont.salario=5000.00; |
|
|
pont->empregado->salario=5000.00; |
|
|
pont.empregado->salario=5000.00; |
|
|
pont.empregado.salario=5000.00 |
Explicação: Criar a entrada:
salario=5000.00; |
|
| Ref.:
201402526933 |
|
|
| 7a Questão |
|
|
| Ref.:
201401723358 |
|
|
| 8a Questão |
|
|
Tenho uma lista não ordenada de clientes em que registro apenas a matrícula, o nome, o
endereço e o telefone de cada cliente. Como não tenho limites para o
crescimento da minha lista, como posso implementar a inserção de um novo
cliente na lista, sabendo que cada cliente é do tipo Cliente e a lista é
do tipo Lista assim definidos :
struct Cliente {
long int matricula;
string nome, endereco, tel;
};
struct Lista {
Cliente c;
struct Lista *link;
};
|
|
|
|
|
Lista * insereCliente(Lista *p, Cliente cl)
{
Lista *novo = new Lista;
novo.c = cl;
novo.link = p;
return novo;
}
|
|
|
Lista insereCliente(Lista *p, Cliente cl)
{
Lista novo[];
novo[0].c = cl;
novo[0].link = p;
return novo;
}
|
|
|
Lista * insereCliente(Lista *p, Cliente cl)
{
Lista *novo ;
novo->c = cl;
novo->link = p;
return novo;
}
|
|
|
Lista * insereCliente(Lista *p) {
Lista *novo = new Lista;
Cliente cl;
novo->c = cl;
novo->link = p;
return novo;
}
|
|
|
Lista * insereCliente(Lista *p, Cliente cl)
{
Lista *novo = new Lista;
novo->c = cl;
novo->link = p;
return novo;
| Ref.:
201401724217 |
|
|
| 1a Questão |
|
|
Seja o seguinte exemplo de nodo de uma lista de encadeada:
struct nodo{
float valor;
string produto;
nodo * proximo;
};
Sabendo-se que nesta lista o último nó ou nodo possui o campo próximo nulo (null), marque a alternativa que representa corretamente a operação de busca do último nodo, a partir de um ponteiro pt apontado para o primeiro nodo da lista.
|
|
|
|
|
while(próximo)pt=próximo;
|
|
|
while(pt->próximo != null)pt=pt->próximo->proximo;
|
|
|
while(pt != null)pt=pt->próximo;
|
|
|
while(pt->próximo->proximo)pt=pt->próximo;
|
|
|
while(pt->próximo)pt=pt->próximo;
|
Explicação: O código será:
while(pt->próximo)pt=pt->próximo; |
|
| Ref.:
201402229903 |
|
|
| 2a Questão |
|
|
| Sobre as estruturas de dados existentes podemos afirmar que: |
|
|
|
|
Na estrutura do tipo FIFO, as informações são inseridas no início e removidas do final. |
|
|
Na estrutura do tipo LIFO, as informações são inseridas no início e removidas do final. |
|
|
Encadeamento estático e dinâmico apresentam o mesmo funcionamento de alocação na estrutura do tipo PILHA. |
|
|
A estrutura do tipo LIFO sempre realiza a remoção do elemento mais antigo inserido. |
|
|
Na estrutura das Pilhas a manipulação dos dados sempre se dá no topo. |
Explicação:
 |
Na estrutura do tipo FIFO, as informações são inseridas no início e removidas do final. |
| Falso. Fila segue a lógica FIFO, ou seja, o primeiro
a entrar será o primeiro a sair. Logo, insere no fim e retira do início
da fila. |
|
Na estrutura do tipo LIFO, as informações são inseridas no início e removidas do final. |
| Falso. Pilha segue a lógica LIFO, o último a entrar
será o primeiro a sair. Insere-se no topo e retira-se do topo , ou
seja, da mesma extremidade. |
 |
Na estrutura das Pilhas a manipulação dos dados sempre se dá no topo. |
| Verdade. SEgue-se a lógica LIFO. |
|
Encadeamento estático e dinâmico apresentam o mesmo funcionamento de alocação na estrutura do tipo PILHA. |
| Falso. No encadeamento estático a alocação é
contígua e ocorre antes da execução. No encadeamento dinâmico a
alocação de memória ocorre em tempo de execução e o armazenamento é
encadeado. |
|
A estrutura do tipo LIFO sempre realiza a remoção do elemento mais antigo inserido.
|
Falso. A remoção se dá no último inserido, ou seja, o mais novo inserido na pilha.
|
|
| Ref.:
201401689302 |
|
|
| 3a Questão |
|
|
Assinale a opção correta. Sobre pilha dinâmica podemos afirmar que :
|
|
|
|
|
usa o critério FIFO, visto que é dinâmica. |
|
|
usa o critério LIFO e é implementada usando-se listas encadeadas. |
|
|
insere-se em qualquer posição, antes ou após qualquer nó, visto que é dinâmica.
|
|
|
só pode ter seus dados impressos no sentido do último nó para o primeiro nó.
|
|
|
é recomendada para qualquer tipo de aplicação em que insere-se no final e retira-se do início.
|
|
| Ref.:
201402190147 |
|
|
| 4a Questão |
|
|
| Ref.:
201402106745 |
|
|
| 5a Questão |
|
|
Sobre uma estrutura de dados do tipo LIFO, observe as seguintes afirmações:
(1) É uma pilha.
(2) Pode ser uma fila com prioridades
(3) É uma estrutura onde o primeiro elemento a entrar é o último a sair.
Sobre estas afirmações marque a opção correta: |
|
|
|
|
Apenas a afirmação (1) é verdadeira |
|
|
Apenas a afirmação (3) é verdadeira |
|
|
Todas as afirmações são falsas |
|
|
Todas as afirmações são verdadeiras |
|
|
Apenas as afirmações (1) e (3) são verdadeiras |
|
| Ref.:
201402027470 |
|
|
| 6a Questão |
|
|
| Ref.:
201402061958 |
|
|
| 7a Questão |
|
|
| Assinale a característica que NÃO está relacionada às estruturas de dados encadeadas: |
|
|
|
|
Consomem memória de maneira permanente, só sendo liberadas ao fim do programa. |
|
|
Cada elemento guarda pelo menos um ponteiro para outro elemento da estrutura. |
|
|
A memória ocupada por seus elementos é, em geral, liberada com o uso de delete.
|
|
|
Em geral, marca-se o último elemento com um ponteiro de valor NULL. |
|
|
A memória para armazenar seus elementos é, em geral, alocada com o uso de new. |
|
| Ref.:
201402549139 |
|
|
| 8a Questão |
|
|
A
pilha é uma estrutura de dados que permite a inserção/ remoção de itens
dinamicamente seguindo a norma de último a entrar, primeiro a sair.
Suponha que para uma estrutura de dados, tipo pilha, são definidos os
comandos:
- PUSH (p, n): Empilha um número "n" em uma estrutura de dados do tipo pilha "p";
- POP (p): Desempilha o elemento do topo da pilha.
Considere que, em uma estrutura de dados tipo pilha p, inicialmente vazia, sejam executados os seguintes comandos:
PUSH (p, 10)
PUSH (p, 5)
PUSH (p, 3)
PUSH (p, 40)
POP (p)
PUSH (p, 11)
PUSH (p, 4)
PUSH (p, 7)
POP (p)
POP (p)
Após a execução dos comandos, o elemento no topo da pilha "p" e a
soma dos elementos armazenados na pilha "p" são, respectivamente, |
|
|
|
|
7 e 40. |
|
|
7 e 29. |
|
|
4 e 80. |
|
|
11 e 29. |
| Ref.:
201402131890 |
|
|
| 1a Questão |
|
|
Considere uma lista duplamente encadeada não circular em que
struct nodupla {
int dado;
struct nodupla *dlink; // aponta p/ o nó à direita
struct nodupla *elink; // aponta p/ o nó à esquerda
};
sendo nodupla *p; //ponteiro para o início da lista
A opção que corretamente mostra as instruções para inserir um valor no início da lista apontada por p é :
|
|
|
|
|
nodupla *novo;
novo = new nodupla;
novo->dado = valor;
novo->dlink = p;
novo->elink = NULL;
if (p != NULL)
p->elink = novo;
p = novo;
|
|
|
n nodupla *novo;
novo = new nodupla;
novo->dado = valor;
novo->elink = NULL;
if (p != NULL)
p->elink = novo;
p = novo;
|
|
|
n
nodupla *novo;
novo = new nodupla;
novo->dado = valor;
novo->dlink = p;
if (p != NULL)
p->elink = novo;
p = novo;
|
|
|
nodupla *novo;
novo = new nodupla;
novo.dado = valor;
novo.dlink = p;
novo.elink = NULL;
if (p != NULL)
p.elink = novo;
p = novo;
|
|
|
nodupla *novo;
novo = new nodupla;
novo->dado = valor;
novo->dlink = p;
novo->elink = NULL;
p->elink = novo;
p = novo;
|
|
| Ref.:
201401484028 |
|
|
| 2a Questão |
|
|
| Em uma lista linear duplamente encadeada.
|
|
|
|
|
O ponteiro do "primeiro" nó não é NULL, mas sim aponta de volta para o "primeiro" nó da lista, formando um ciclo.
|
|
|
Além do campo relativo ao dado, cada nó possui dois ponteiros.
|
|
|
Cada ponteiro possui um só endereço que referencia o primeiro nó da lista.
|
|
|
O ponteiro do "último" nó não é NULL, mas sim aponta de volta para o "primeiro" nó da lista.
|
|
|
Cada nó possui um só ponteiro que referencia o próximo nó da lista.
|
|
| Ref.:
201401484356 |
|
|
| 3a Questão |
|
|
| As
listas encadeadas podem ser elaboradas de duas formas utilizando uma
técnica de encadeamento simplesmente ou encadeamento duplo. O que difere
uma lista simplesmente encadeada de uma lista duplamente encadeada? |
|
|
|
|
Em uma lista duplamente encadeada cada nó aponta para nó seguinte e para o primeiro nó da fila. |
|
|
Em uma lista simplesmente encadeada cada nó aponta para nó seguinte e para o nó anterior. |
|
|
Em uma lista duplamente encadeada, cada nó aponta para um nó enquanto a lista simplesmente encadeada aponta para mais de um nó. |
|
|
Em uma lista duplamente encadeada cada nó aponta para nó seguinte. |
|
|
Em
uma lista simplesmente encadeada cada nó aponta para um único nó
enquanto a lista duplamente encadeada aponta para mais de um nó. |
|
| Ref.:
201402148301 |
|
|
| 4a Questão |
|
|
Os
registros também conhecidos como estruturas, são estruturas de dados do
tipo heterogêneo, ou seja, permitem que valores de tipos diferentes
possam ser armazenados em uma mesma estrutura. Analisando a estrutura
abaixo, a mesma pode ser utilizada para qual tipo de estrutura de dados,
marque a alternativa correta.
struct nomeRegistro{
int info;
struct nomeRegistro* ant;
struct nomeRegistro* prox;
};
typedef struct nomeRegistro NOMEREGISTRO; |
|
|
|
|
Matriz |
|
|
Pilha |
|
|
Fila |
|
|
Lista duplamente encadeada |
|
|
Lista encadeada |
|
| Ref.:
201401686646 |
|
|
| 5a Questão |
|
|
Em
uma lista duplamente encadeada, seus nodos são compostos por campos
cujos tipos podem ser de diferentes naturezas, entretanto dois de seus
campos devem ser ponteiros para o mesmo tipo do nodo, são estes os
ponteiros ant e prox, que apontam respectivamente para o nodo anterior e
para o próximo nodo. Esta característica permite que a estrutura seja
percorrida em ambos os sentidos. Assim analisando as operações a seguir:
p->ant->prox=p->prox;
p->prox->ant=p->ant;
Sendo p um ponteiro que aponta para um dos nodos da lista, pode-se afirmar que:
|
|
|
|
|
As operações possibilitam a busca de um nodo apontado pelo ponteiro p. |
|
|
As operações possibilitam o percurso do ponteiro p da esquerda para direita. |
|
|
As operações inserem novo nodo, após o nodo apontado pelo ponteiro p. |
|
|
As operações possibilitam o percurso do ponteiro p da direita para esquerda. |
|
|
As operações removem o nodo apontado pelo ponteiro p. |
|
| Ref.:
201402146152 |
|
|
| 6a Questão |
|
|
| Qual a estrutura de dados usada na implementação do método Round Robin do sistema operacional UNIX ? |
|
|
|
|
Lista simplesmente encadeada |
|
|
Árvore |
|
|
Fila |
|
|
Lista duplamente encadeada |
|
|
Pilha |
Explicação: Não tem outra possibilidade. Resposta objetiva. |
|
| Ref.:
201401484377 |
|
|
| 7a Questão |
|
|
| Geralmente
em algumas situações é necessário fazer a desalocação do espaço
utilizado na memória. Porém, isso depende de como a reserva de uma
quantidade de espaço de memória é feita, pois em alguns casos, o próprio
compilador faz a desalocação. Quando o compilador não faz esta
desalocação a memória foi reservada utilizando______. |
|
|
|
|
Declaração de vetor |
|
|
Alocação dinâmica de memória |
|
|
Declaração de matriz |
|
|
Alocação estática de memória |
|
|
Declaração de função |
Explicação: Se for necessário liberar a memória ocupada por essas variáveis, é preciso recorrer à função free.
A função free desaloca a porção de memória alocada por malloc.
A instrução free (ptr) avisa ao sistema que o bloco de bytes apontado por ptr está disponível para reciclagem. |
|
| Ref.:
201402218047 |
|
|
| 8a Questão |
|
|
| Ao
criarmos uma rotina para inserir um dado em uma LISTA de dados
duplamente encadeada e circular, nos deparamos com as seguintes
cuidados:
|
|
|
|
|
Só poderei inserir no final da lista e nunca no começo ou no meio. |
|
|
Só poderei inserir no final da lista e no começo somente se ela estiver cheia. |
|
|
Só poderei inserir no começo ou no fim, mas não no meio. |
|
|
Posso inserir no começo, no meio ou no fim. |
|
|
Só poderei inserir no final da lista e no começo somente se ela estiver vazia. |
Explicação: Em
uma lista duplamente encadeada circular ou não, podemos inserir ou
remover de qualquer parte da lista. Não há problema na inserção se a
lista estiver vazia. |
|
|
| | | |
|
|
|
Comentários
Postar um comentário