Exércicio 10 - Estrutura de dados

Prévia do material em texto

CCT0753_EX_A10_201801153345_V1
 
 
 
 ESTRUTURA DE DADOS 10a aula
 Lupa 
Vídeo
 
PPT
 
MP3
 
 
Exercício: CCT0753_EX_A10_201801153345_V1 24/05/2019 (Finaliz.)
Aluno(a): JORGIVALDO NOGUEIRA LEAL 2019.1 EAD
Disciplina: CCT0753 - ESTRUTURA DE DADOS 201801153345
 
 1a Questão
Uma estrutura de dados em lista duplamente encadeada permite na cadeia movimentos para:
frente, apenas.
cima e para baixo ou para frente e para trás.
trás, apenas.
cima e para baixo, apenas.
 frente e para trás, apenas.
Respondido em 24/05/2019 22:44:56
 
 
Explicação:
Nas listas dulamente encadeadas há 2 ponteiros : um que aponta para o nó à direita e outro que aponta para o nó à esquerda.
Gabarito
 Coment.
 
 
 2a Questão
Com relação à lista duplamente encadeada, é correto afirmar que :
 A lista precisa ter sempre um ponteiro apontando para o 1º. nó
 A lista pode ser percorrida com igual facilidade para a direita ou para a esquerda,
pois existem dois ponteiros.
Não pode ser vazia.
Não pode haver remoções no meio da lista.
Consome menos memória do que uma lista simplesmente encadeada, se tivermos
uma mesma aplicação.
Respondido em 24/05/2019 22:45:29
Gabarito
 Coment.
 
 
 3a Questão
 Suponha uma listagem mantida com informações sobre um equipamento a ser adquirido por uma
empresa. A listagem possui as informações sobre de 10 fornecedores, descritas a seguir:
próximo: um ponteiro para o próximo fornecedor da listagem;
nome: nome, identificando o fornecedor;
 valor: preço do equipamento no fornecedor; 
 anterior: um ponteiro para o fornecedor anterior da listagem.
Sendo o fornecedor "Z" o quinto elemento desta listagem e "X" e "Y" dois outros fornecedores que
não pertencem à listagem, com seus respectivos ponteiros "pZ", "pX" e "pY", considere o trecho de
código abaixo.
pY->proximo = pX;
pX->anterior = pY;
pX->proximo = pZ->proximo;
pZ->proximo->anterior = pX;
pZ->proximo = pY;
pY->anterior = pZ;
Este trecho de código é usado para inserir na listagem os fornecedores:
X, antes do Z, e Y, logo após o Z.
 Y, logo após o Z, e X, logo após o Y.
X, logo após o Z, e Y, logo após o X.
Y, antes do Z, e X, antes do Y.
Y, antes do Z, e X, logo após o Z.
Respondido em 24/05/2019 22:47:49
Gabarito
 Coment.
 
 
 4a 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 removem o nodo apontado pelo ponteiro p.
As operações possibilitam o percurso do ponteiro p da direita para esquerda.
Respondido em 24/05/2019 22:49:40
 
 
 5a 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______.
 Alocação dinâmica de memória
Declaração de matriz
Declaração de função
Declaração de vetor
Alocação estática de memória
Respondido em 24/05/2019 22:50:27
 
 
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.
 
 
 6a Questão
Sobre as estruturas de dados lineares, assinale V ou F:
I - Em uma pilha, o último elemento a entrar é o primeiro a sair.
II - Em uma fila, o primeiro elemento a entrar é o último a sair.
III - Uma lista permite que as inserções possam ser feitas em qualquer lugar (posição), mas as remoções, não.
IV - Em uma lista circular com encadeamento simples, o primeiro elemento aponta para o segundo e para o último.
V - Para remover um elemento de uma lista duplamente encadeada, deve-se alterar o encadeamento dos elementos anterior e
próximo ao elemento removido. A sequência correta de cima para baixo:
V,F,V,F,V
 V,F,F,F,V
V,F,F,V,F
F,F,V,V,V
F,V,V,F,F
Respondido em 24/05/2019 22:51:50
 
 
Explicação:
Vamos analisar cada afirmativa.
Analisando a afirmativa I : Correto, pois a estrutura pilha segue a lógica LIFO.
 
Analisando a afirmativa II : Falso. Na estrutura de dados fila, o primeiro a entrar é
o primeiro a sair, pois segue a lógica FIFO.
 
Analisando a afirmativa III : Falso. Em uma lista tanto as inserções quanto as
remoções podem ser feitas em qualquer posição.
 
Analisando a afirmativa IV : Falso. Em uma lista circular, o1o. elemento aponta
para o segundo elemento, mas o último elemento aponta para o 1º. elemento da
lista.
 
Analisando a afirmativa V : Está correta.
 
Logo, a opção correta é V, F, F, F, V
 
 
 7a Questão
Um tipo de estrutura de dados é declarada em C como:
 typedef struct no *apontador;
 struct no{
 int valor;
 apontador esq, dir;
 }
onde esq e dir representam ligações para os dados da esquerda e direita, respectivamente. Qual das seguintes alternativas é uma
implementação correta da operação que inverte as posições dos dados da esquerda e da direita uma estrutura p, onde t é um
apontador auxiliar.
p->dir=t;
 p->esq = p->dir;
 p->dir = t;
 t=p->dir;
 p->dir = p->esq;
 p->esq = t;
t=p;
 p->esq = p->dir;
 p->dir = p->esq;
t=p->dir;
 p->esq = p->dir;
 p->dir = t;
p->esq = p->dir;
 t = p->esq;
 p->dir = t;
Respondido em 24/05/2019 22:52:03
 
 
Explicação:
O código pedido é:
t=p->dir;
 p->dir = p->esq;
 p->esq = t;
 
 
 8a Questão
Observe a struct, definida globalmente, e um trecho de uma função que manipula uma
Lista Duplamente Encadeada.
struct listaDE
{
 int info;
 struct listaDE* ant;
 struct listaDE* prox;
};
...
listaDE* novo = new listaDE;
novo->info = valor;
novo->prox = LISTA;
novo->ant = NULL; 
Assinale a alternativa que apresenta o protótipo dessa função
listaDE *busca (listaDE *LISTA, int valor);
void exibeIpF(listaDE *LISTA);
 listaDE *insereInicio(listaDE *LISTA, int valor); 
listaDE *remove(listaDE *LISTA, int valor);
 listaDE *insereFim(listaDE *LISTA, int valor);
Respondido em 24/05/2019 22:52:46
Gabarito
 Coment.