Simulado de Estrutura de Dados

1 - Descreva a diferena observada entre as diversas Estruturas citadas

A diferena se da na forma de I/O, ou seja, armazenamento e recuperao dos dados.

2 - O que NPR? Em qual estrutura aplica-se esta prtica?

NPR significa Notao Polonesa Reversa e aplica-se na estrutura de Pilha.

3 - Quais operaes so permitidas nas estruturas de Filas e Pilhas?

Insero, remoo, alterao e consulta.

4 - Desenhe a seguinte rvore

Total de folhas (ramificaes): 6
Total mximo de grau (ramificaes no mesmo n): 4
Altura da rvore: 6

b c d c
3
6

f g h j
2 4 5
i

l
1

5 - Entre as tcnicas mencionadas (Hashing e Busca Binria), cite as suas diferenas

Hashing
A tcnica hashing tem a finalidade de espalhar os dados em N classes ou chaves, obtendo desta forma um rpido
acesso aos dados. Os dados no precisam estar classificados.

Busca Binria
uma tcnica que permite desenvolver o particionamento de uma base de dados em n divises sendo exigido que os
dados estejam organizados. Est tcnica tambm conhecida por arvore de indexao.

6 - Desenhe a Rotina de Insero de Pilha, aplicando ponteiro

(Ver cdigos auxiliares)

7 - Para obter sucesso na recuperao de dados em uma Busca Binria, necessrio que a mesma esteja o que?
necessrio que os dados estejam organizados

8 - A Busca Binria baseada em que estrutura?

Arvores Binrias

9 - Desenhe a Rotina de Remoo de Fila, aplicando Ponteiro

(Ver cdigos auxiliares)

10 - Explique os termos Job e Task. Em qual estrutura aplicado?

JOB - um programa que tem com finalidade desenvolver uma ou mais tarefas.
Task - uma tarefa que parte integrante de um job.

11 - Em que aplicao podemos afirmar que as estruturas de rvores e rvores binrias so utilizadas?
Arvores Binria - sua aplicao ocorre em organizaes de registro tanto em arquivos convencionais quanto em
tabela de banco de dados.

Arvores - uma estrutura linear que gerencia pasta ou subdiretrios em sistemas operacionais.

12 - O termo estrutura genrica ou hbrida, baseada em que?

As estrutura genrica ou hibrida so estruturas de dados que aplicaes exige sendo a juno de filas, pilhas, arvores e
listas. Podemos utilizar destas estruturas para fins de vrias aplicaes.

13 - Podemos aplicar a tcnica de hashing em uma base de dados organizada?

Sim, em hashing no necessrio que os dados estejam organizados. Mesmo os dados organizados no ir ocorrer
diferena no espalhamento ou no resultado do mtodo.

14 - Desenhe a Rotina de Remoo de Pilha, aplicando ponteiro

(Ver cdigos auxiliares)

 Cdigos Auxiliares:

Pilhas:

#include <stdio.h>
#include <conio.h>
#define TAM_VET 10
#define VERD 1
#define FALSO 0
#define ERRO -1

void Inic_Pilha (int *Topo)

{
*Topo = -1;
}

int Pilha_Vazia(int Topo)

{
if (Topo == -1) return(VERD);
return(FALSO);
}

int Pilha_Cheia(int Topo)

{
if (Topo == TAM_VET-1) return(VERD);
return(FALSO);
}

int Empilha(float P[], int *Topo, float x)

{
if (*Topo == TAM_VET-1)
{
printf("Erro - Pilha cheia");
return(ERRO);
}
else
{
(*Topo)++;
P[*Topo] = x;
}
return(VERD);
}

int Desempilha(float P[], int *Topo, float *x)

{
if (*Topo == -1)
{
printf("Erro - Pilha vazia");
return(ERRO);
}
else
{
*x = P[*Topo];
(*Topo)--;
}
return(VERD);
}
int main()
{
float P[TAM_VET];
int Topo;
int ok,op=0;
float dado;
system("cls");
Inic_Pilha(&Topo);
while ( op != 3 )
{
printf("\n\nMenu\n1-Inserir\n2-Excluir\n3-Fim\nOpcao: ");
scanf("%d", &op);
if ( op == 1)
{
printf("\nDigite um numero: ");
scanf("%f", &dado);
Empilha(P,&Topo,dado);
}
else if ( op == 2 )
{
ok = Desempilha(P,&Topo,&dado);
if ( ok != ERRO)
printf("\nElemento removido: %f", dado);
}
}
}

Filas:

/* Convenes:
frente = 0 e fim = -1
frente > fim indica fila vazia.
fim = TAM_VET - 1 indica fila cheia
*/

#include <stdio.h>
#include <conio.h>
#define TAM_VET 10
#define VERD 1
#define FALSO 0
#define ERRO -1

void Inic_Fila(int *frente, int *fim)

{
*frente = 0;
*fim = -1;
}

int Fila_Vazia(int frente, int fim)

{
if (frente > fim) return(VERD);
return(FALSO);
}

int Fila_Cheia(int fim)

{
if (fim == TAM_VET-1) return(VERD);
return(FALSO);
}

int Insere_Fila(float F[], int *fim, float x)

{
if (*fim == TAM_VET-1) {
printf("Erro - Fila cheia");
return(ERRO);
}
else
{
(*fim)++;
F[*fim] = x;
}
return(VERD);
}
int Remove_Fila(float F[], int *frente, int *fim, float *x) {
if (*frente > *fim)
{
printf("Erro - Fila vazia");
return(ERRO);
}
else
{
*x = F[*frente];
(*frente)++;
}
return(VERD);
}

int main()
{
float F[TAM_VET];
int frente,fim;
int ok,op=0;
float dado;
system("cls");
Inic_Fila(&frente, &fim);
while ( op != 3 ) {
printf("\n\nMenu\n1-Inserir\n2-Excluir\n3-Fim\nOpcao: ");
scanf("%d",&op);
if ( op == 1)
{
printf("\nDigite um numero: ");
scanf("%f",&dado);
Insere_Fila(F, &fim, dado);
}
else if ( op == 2 )
{
ok = Remove_Fila(F, &frente, &fim, &dado);
if ( ok != ERRO)
printf("\nElemento removido: %f", dado);
}
}

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef struct cidade

{
long int populacao;
char nome[31], estado[3];
float area;
struct cidade *prox;
} cidade;

void insere_inicio(cidade**lista,char nome[], float area, long int pop, char estado[])
{
cidade *novo;
novo=(cidade*)malloc(sizeof(cidade));
if(novo==NULL)
printf("\nNao ha memoria");
else
{
strcpy(novo->nome,nome);
strcpy(novo->estado,estado);
novo->populacao=pop;
novo->area=area;
novo->prox=*lista;
*lista=novo;
system("cls");
printf("\nSucesso\n");
}
}
void imprime_maior_pop(cidade *lista)
{
cidade *maior=lista;
if(lista==NULL)
{
system("cls");
printf("\n Lista vazia\n");
}
else
{
while(lista!=NULL)
{
if(lista->populacao>maior->populacao)
maior=lista;
lista=lista->prox;
}
system("cls");
printf("\n Nome=%s Area=%.2fkm pop=%ld estado=%s\n", maior->nome, maior-
>area, maior->populacao, maior->estado);
}
}

void imprime_todos_dens(cidade *lista)

{
system("cls");
while(lista!=NULL)
{
printf("\n Nome=%s Area=%.2fkm pop=%ld estado=%s dens=%.2farea/pop\n",
lista->nome, lista->area, lista->populacao, lista->estado, (lista->populacao/(lista-
>area)));
lista=lista->prox;
}
}

void imprime_pop_maior(cidade *lista)

{
int flag=0;
if(lista==NULL)
{
system("cls");
printf("\n Lista vazia\n");
return;
}
else
{
system("cls");
while(lista!=NULL)
{
if(lista->populacao>200000)
{
flag=1;
printf("\n Nome=%s Area=%.2fkm pop=%ld estado=%s\n", lista-
>nome, lista->area, lista->populacao, lista->estado);
}
lista=lista->prox;
}
}
if(flag==0)
printf("Nao ha cidade com populacao > 200.000 cadastrado!\n");
}

long int tot_por_estado(cidade *lista, char estado[])

{
long int total=0;
while(lista!=NULL)
{
if(strcmp(lista->estado, estado)==0)
{
total+=lista->populacao;
}
lista=lista->prox;
}
return(total);
}
void remove_inicio(cidade **lista)
{
cidade *aux;
if(*lista==NULL)
{
system("cls");
printf("\n Lista vazia\n");
}
else
{
aux=*lista;
*lista=aux->prox;
system("cls");
printf("\n Cidade %s removida com sucesso!\n", aux->nome);
free(aux);
}
}

int main()
{
cidade *lista=NULL;
int opcao=0;
char nome[31], estado[3];
float area;
long int pop;
do
{
printf("\n***MENU***\n");
printf("\n1 - Insere inicio");
printf("\n2 - Imprime cidade com maior populacao");
printf("\n3 - Densidade");
printf("\n4 - Imprime cidade com populacao > 200.000");
printf("\n5 - Soma de pop das cidades de um estado definido pelo
usuario");
printf("\n6 - Remover cidade do inicio");
printf("\n9 - Sair");
printf("\n\nDigite a opcao: ");
scanf("%d", &opcao);
switch(opcao)
{
case 1:
printf("\nDigite o nome da cidade: ");
fflush(stdin);
gets(nome);
printf("\nDigite o estado: ");
scanf("%s", &estado);
printf("\nDigite a extencao territorial: ");
scanf("%f", &area);
printf("\nDigite a populacao: ");
scanf("%ld", &pop);
insere_inicio(&lista, nome, area, pop, estado);
break;
case 2:
imprime_maior_pop(lista);
break;
case 3:
imprime_todos_dens(lista);
break;
case 4:
imprime_pop_maior(lista);
break;
case 5:
printf("\nDigite estado: ");
fflush(stdin);
gets(estado);
system("cls");
printf("\nTotal do estado %s = %ld\n", estado,
tot_por_estado(lista,estado));
break;
case 6:
remove_inicio(&lista);
break;
 case 9:
system("cls");
printf("\nObrigado por utilizar nossos servicos\n\n");
system("pause");
break;
default:
system("cls");
printf("\nOpcao invalida!\n");
}
} while(opcao!=9);
}
rvores

- Fudamentos

Uma rvore uma coleo finita de n >= 0 nodos. Se n = 0, dizemos que a rvore nula, caso contrrio uma rvore
apresenta as seguintes caractersticas :

- Existe um nodo especial denominado raiz;

- Os demais so particionados em t1..tn, estruturas disjuntas de rvores;
- As estruturas t1..tn denomina-se sub-arvores;
A exigncia de que as estruturas t1...tn sejam colees disjuntas, garante que um mesmo nodo no aparecer em mais
de uma sub-rvore ao mesmo tempo, ou seja, nunca teremos sub-rvores interligadas. Observe que cada uma das
estruturas t1 organizada na forma de rvore, isto caracteriza uma definio recursiva.
Exemplo :

C
B D

E F G H I S

K L M

Estruturas de uma rvore

A rvore possui uma estrutura que permite a partir da mesma navegao e a recuperao dos dados. A estrutura se
divide em :
GRAU Corresponde o nmero de filhos conectado ao nodo pai; Caso o nodo no tenha dependente considerado
nodo folha, ou numeral zero;
NVEL Corresponde a altura de um determinado nodo. Para referenciar o nvel considera que o nodo raiz esteja
posicionado no nvel 1, os demais nodos nvel n + 1. Tambm podemos definir que uma rvore pode ter altura
mxima, no caso acima, a rvore possui a altura 4.
EXERCCIOS

1) Determine o grau de cada nodo :

Nodo GRAU Nvel Quais os nodos
dependentes
A
I
J
L
M
E

2) Com base no exemplo acima estabelea a seguintes funes e procedimentos :

- Criar n Raiz;
- Cada n pode ter at 3 Grau;
- A altura mxima da rvore deve ter no mximo 4, ao atingir este limite a insero deve ser interrompida.

Arvores generalizadas

Uma lista generalizada uma estrutura conveniente para representar rvores. Devido a sua flexibilidade as listas
generalizadas podem armazenar rvore a qualquer grau.
Por exemplo:

B C D

E F G

Sua representao de forma generalizada :

T: [A,[B,[E]],[C],[D,[F],[G]]

Por definio teremos os seguintes termos:

Head (t) : representa a raiz da rvore;

Tail (t) : representa as sub-rvores da raiz da rvore T;
 Fila

A fila um tipo especial de lista linear em que todas as operaes de insero e remoo so realizadas em
extremidades opostas como inicio e fim.
Devido a esta disciplina de acesso aos elementos, sero sempre removidos na ordem em que foram
inseridos, de modo que o primeiro elemento que entra exatamente o primeiro a ser removido.
Da o faro destas listas serem denominadas de listar FIFO ( first-in / first-out ).
Por definio, uma FIFO uma estrutura dinmica que permite aumentar / diminuir durante a sua
existncia.
Devida a esta caracterstica podemos concluir que as pilhas suportam quais operaes.
Enqueue - insere um novo elemento na lista;
Dequeue - remove um elemento na lista;
getFront - consulta o elemento do topo da lista;
Exemplo:

1) Enqueue F(a);
2) Enqueue F(b);
3) Dequeue F;
4) Enqueue F(c);
5) Enqueue F(d);
6) Dequeue F;
7) Dequeue F;
 Pilha

A pilha um tipo especial de lista linear em que todas as operaes de insero e remoo so realizadas
numa mesma extremidade denominada como topo. Cada vez em que um novo elemento deve ser inserido na pilha,
ele colocado no seu topo e a qualquer momento poderia ser removido.
Devido a esta disciplina de acesso aos elementos, sero sempre removidos na ordem inversa quela em que
foram inseridas, de modo que o ltimo elemento que entra exatamente o primeiro a ser removido.
Da o faro destas listas serem denominadas de listar LIFO ( last-in / first-out ).
Por definio, uma LIFO uma estrutura dinmica que permite aumentar / diminuir durante a sua
existncia.
Devida a esta caracterstica podemos concluir que as pilhas suportam quais operaes.
Push - insere um novo elemento na lista;
Pop - remove um elemento na lista;
Top - consulta o elemento do topo da lista;
Exemplo:

1) Push P (a);
2) Push P (b);
3) Pop P;
4) Push P (c);
5) Push P (d);
6) Pop P;
7) Pop P;

1) a <- P

2) b <- P
a

******
3) ** Pop
a

4) c <- P
a

5) d <- P
c
a

6) d
c <- P
a

7) d
a <- P
Notao polonesa reversa (NPR)

Infixa : O operador aparece entre os operandos (A+B)

Prefixa : O operador precede os operandos (+AB)
Posfixa : O operador segue os operandos (AB+)

Notao infixa Notao Posfixa

A+B*C ABC*+
A*(B+C) ABC+*
(A+B)/(C-D) AB+CD-/
((A+B)/(C-D)*E) AB+CD-E*/

Regras para converter (Infixa para posfixa)

1)Parnteses de abertura (ignore);

2) Parnteses de fechamento (descarrega operador da pilha);
3)Operador vai para pilha;
4)Operando vai para sada.

SMBOLO OPERAO PILHA SADA

( ignore
( ignore
A copia A
+ pilha + A
B copia + AB
) descarrega AB+
/ operador / AB+
( ignora / AB+
( copia / AB+C
- operador -/ AB+C
D copia -/ AB+CD
) descarrega / AB+CD-