Universidade Federal do Piauí – UFPI

Centro de Educação Aberta e a Distância – CEAD

Curso de Licenciatura em Computação
Disciplina: Estrutura de Dados (ReOferta Férias)
Professor: Jenner Vaz Silva
Aluno(a):________________________ Matrícula: ____________
Tutor(a): Jenner Vaz Silva Data: 22 e 23/01/2019 Nota: _____
Polo:_________________________________________________

Trabalho Prova Estrutura de Dados 2018-4

Atente para as orientações contidas no início do seu trabalho (com destaque para as duas
observações) e qualquer alteração no enunciado original de uma questão, anula a respectiva questão.

 Esta atividade é totalmente individual.

 Questões cujo desenvolvimento forem totalmente idênticos a de outros alunos serão
desconsideradas.
 Procure responder de forma clara, dentro do prazo determinado, e em seguida poste o
arquivo (até as 23:59 do dia 23/01) com toda a resolução da avaliação na plataforma.
 Cada aluno só terá direito a enviar um único arquivo.
 Não será considerada qualquer avaliação enviada por email para tutores ou professor
da disciplina. Somente serão corrigidas e atribuídas as notas para as avaliações postadas na
turma virtual.

OBS1: Baixe esse arquivo (no próprio formato do Word) e responda cada uma das questões logo
após a mesma, sem alterar a formatação do espaço (cor, fonte, tamanho, espaçamento) ;
OBS2: Digite com suas palavras a resolução de cada questão abaixo . Qualquer indicativo
que uma questão, foi copiada e colada, limitará a mesma em, pelo menos, 50% do valor da questão (caso o
indicativo não esteja em toda a questão, estando a mesma será anulada).

Pontuação: 1) 2,5pt 2) 2,5pt 3) 2,5pt 4) 2,5pt

1. Em cada alternativa abaixo, diga qual a única opção correta E

JUSTIFIQUE O ERRO DE OUTRAS DUAS OPÇÕES ERRADAS. OBS: Volto a
destacar, não basta indicar a opção correta em cada alternativa, também é necessário
escolher e dizer a razão de duas outras opções estarem erradas.

ALTERNATIVA1: “ Estruturas de Dados e algoritmos estão intimamente ligados.

Não se pode estudar Estruturas de Dados sem considerar os algoritmos associados a elas, assim
como a escolha dos algoritmos em geral depende da representação e da Estrutura de Dados.
Sabe-se que algoritmos manipulam dados. Quando estes dados estão organizados de forma
coerente, podemos caracterizá-los como uma Estrutura de Dados. “ Do trecho acima
retirado de nossa apostila e de nossos conhecimentos, podemos afirmar:

A) As disciplinas de Estrutura de Dados e Programação I não mantém relação entre si

B) Estrutura de Dados (que envolve dados mais complexos) deve ser vista
depois de Programação I.
C) Programação I (que envolve dados mais complexos) deve ser vista depois de
Estrutura de Dados.
D) Estrutura de Dados como não envolve Algoritmo não tem nenhuma relação com
Programação I
 E) As disciplinas de Estrutura de Dados e Programação I são rigorosamente iguais,
possuem o mesmo plano de ensino.
Justificativa de duas opções erradas:

ALTERNATIVA2: “Tipos Abstratos de Dados são tipos criados arbitrariamente pelo

programador, sem que estejam definidos na linguagem de programação como Tipos de
Dados primitivos.” Do trecho acima retirado de nossa apostila e de nossos conhecimentos,
podemos afirmar que o único tipo de dado primitivo existente abaixo é o:

A) Int
B) Lista Linear
C) Pilha
D) Fila
E) Árvore

Justificativa de duas opções erradas:

2. No programa ao lado, temos #include <stdio.h>

a declaração e inicialização de VOGAL #include <stdlib.h>
que é uma estrutura:
int main() {

int indice ;
a) De qual tipo? Justifique char VOGAL[5];

VOGAL[0] = 'a'; VOGAL[1] = 'e';

VOGAL[2] = 'i'; VOGAL[3] = 'o';

VOGAL[4] = 'u';

b) Mencione e caracterize e o printf("As vogais sao: \n");

outro tipo de dado presente neste
for (indice=0 ; indice < 5; indice +=1)
programa.
{ printf(" %c \n", VOGAL[indice] ); }

system("Pause");

return 0 ;

}
 3. Nosso colega “Thiago Dias” interagiu no Fórum com a postagem
abaixo . Mencione:
a) Três usos práticos das árvores

c) Como são chamados os elementos associados aos nós sem filhos

4. Referente ao programa abaixo, adaptado de uma postagem, responda:

a) Ele utiliza uma estrutura LIFO ou FILA? Justifique.

b) Ele apresenta algum erro? Justifique.

======

#include <stdio.h>
#include <stdlib.h>
struct Node{
int num;
struct Node *prox;
};
typedef struct Node node;
int tam;
int menu(void);
void inicia(node *PILHA);
void opcao(node *PILHA, int op);
void exibe(node *PILHA);
void libera(node *PILHA);
void push(node *PILHA);
node *pop(node *PILHA);
int main
{
node *PILHA = (node *) malloc(sizeof(node));
if(!PILHA){
printf("Sem memoria disponivel!\n");
exit(1);
}else{
inicia(PILHA);
int opt;
do{
opt=menu();
opcao(PILHA,opt);
}while(opt);

free(PILHA);
return 0;
}
}
void inicia(node *PILHA)
{
PILHA->prox = NULL;
tam=0;
}
int menu(void)
{
int opt;
printf("Escolha a opcao\n");
printf("0. Sair\n");
printf("1. Zerar PILHA\n");
printf("2. Exibir PILHA\n");
printf("3. PUSH\n");
printf("4. POP\n");
printf("Opcao: "); scanf("%d", &opt);
return opt;
}
void opcao(node *PILHA, int op)
{
node *tmp;
switch(op){
case 0:
libera(PILHA);
break;
case 1:
libera(PILHA);
inicia(PILHA);
break;
case 2:
exibe(PILHA);
break;
case 3:
push(PILHA);
break;
case 4:
tmp= pop(PILHA);
if(tmp != NULL)
printf("Retirado: %3d\n\n", tmp->num);
break;
default:
printf("Comando invalido\n\n");
}
}
int vazia(node *PILHA)
{
if(PILHA->prox == NULL)
return 1;
else
return 0;
}
node *aloca()
{
node *novo=(node *) malloc(sizeof(node));

if(!novo){
printf("Sem memoria disponivel!\n");
exit(1);
}else{
printf("Novo elemento: "); scanf("%d", &novo->num);
return novo;
}
}
void exibe(node *PILHA)
{
if(vazia(PILHA)){
printf("PILHA vazia!\n\n");
return ;
}
node *tmp;
tmp = PILHA->prox;
printf("PILHA:");
while( tmp != NULL){
printf("%5d", tmp->num);
tmp = tmp->prox;
}
printf("\n ");
int count;
for(count=0 ; count < tam ; count++)
printf(" ^ ");
printf("\nOrdem:");
for(count=0 ; count < tam ; count++)
printf("%5d", count+1);
printf("\n\n");
}
void libera(node *PILHA)
{
if(!vazia(PILHA)){
node *proxNode,
*atual;
atual = PILHA->prox;
while(atual != NULL){
proxNode = atual->prox;
free(atual);
atual = proxNode;
}
}
}
void push(node *PILHA)
{
node *novo=aloca();
novo->prox = NULL;
if(vazia(PILHA))
PILHA->prox=novo;
else{
node *tmp = PILHA->prox;
while(tmp->prox != NULL)
tmp = tmp->prox;
tmp->prox = novo;
}

tam++;
}
node *pop(node *PILHA)
{
if(PILHA->prox == NULL){
printf("PILHA ja vazia\n\n");
return NULL;
}else{
node *ultimo = PILHA->prox,
*penultimo = PILHA;
while(ultimo->prox != NULL){
penultimo = ultimo;
ultimo = ultimo->prox;
}
penultimo->prox = NULL;
tam--;
return ultimo;
}
}