Estrutura de dados.pdf

Prévia do material em texto

1a Questão (Ref.: 201201093768) Pontos: 0,1 / 0,1 
As coleções de dados podem ser classificadas em estruturas lineares e estruturas não lineares. Nesse contexto, 
é correto afirmar que 
 
 
na pilha, uma estrutura não linear, os elementos são colocados e retirados por um único lado da lista, ou 
seja, pelo topo, que é alterado sempre que um elemento é adicionado ou retirado da pilha. É um tipo de 
estrutura que tem a ordenação do tipo LILO. 
 
a lista é uma estrutura linear cuja implementação pode ser feita por meio de lista ligada em que as 
estruturas são estáticas ou através de um array para permitir que as estruturas sejam ligadas 
dinamicamente. 
 na tabela de Hash a chave é transformada num índice inteiro que é usado para acessar os dados. A 
chave pode ser um string, desde que haja uma função que transforme essa chave num inteiro. É uma 
estrutura linear. 
 
a fila de prioridade é uma versão especial da fila, uma estrutura não linear. Quando se retira um 
elemento desta estrutura é selecionado aquele que tem maior prioridade, tendo portanto a ordenação do 
tipo FIFO. 
 
tendo uma estrutura não linear, um array dinâmico é criado usando técnicas de alocação e gestão 
dinâmica de memória. Pode ser redimensionado e é alocado durante o tempo de compilação. 
 
 
 
 2a Questão (Ref.: 201201826267) Pontos: 0,1 / 0,1 
Marque a opção verdadeira para um ponteiro. 
 
 
É uma varável que pode armazenar um endereço de memória ou um valor do tipo inteiro 
 É uma variável que armazena o endereço de um valor do tipo para o qual o ponteiro foi declarado 
 
É uma variável que, quando incrementada de uma unidade, sempre incrermenta o seu valor, em termos 
absolutos, de uma unidade 
 
É uma varíavel que armazena como valor necessariamente o endereço onde estará armazenado um 
outro endereço 
 
É uma variável que armazena o endereço de um valor do tipo void 
 
 
 
 3a Questão (Ref.: 201201113491) Pontos: 0,1 / 0,1 
O registro de ativação de uma sub-rotina é o conjunto das informações que devem/precisam ser alocadas em 
memória. Assinale abaixo a única opção que representa a composição destas informações. 
 
 
( ) endereço de ponteiro / variáveis locais / endereço inicial 
 
( ) endereço de retorno / valor de retorno / endereço de ponteiro 
 ( ) endereço de retorno / variáveis locais / parâmetros passados 
 
( ) variáveis locais / valor de retorno / endereço de ponteiro 
 
( ) parâmetros passados / endereço inicial / endereço de retorno 
 
 
 
 4a Questão (Ref.: 201201110480) Pontos: 0,1 / 0,1 
Sobre o funcionamento da busca binária, é incorreto afirmar que dividindo seu vetor em duas metades. 
 
 Se o item for igual ao item que está na metade do vetor, o item não foi encontrado. 
 
Se o item for maior que o item que está na metade do vetor procure na segunda metade, ou seja, a da 
direita. 
 
Se o item for igual ao item que está na metade do vetor, o item foi encontrado. 
 
Se o item for menor que o item que está na metade do vetor, procure na primeira metade, ou seja, a da 
esquerda. 
 
Se o item for menor ao item que está na primeira posição do vetor, o item não foi encontrado. 
 Gabarito Comentado. 
 
 
 
 5a Questão (Ref.: 201201830167) Pontos: 0,1 / 0,1 
No programa abaixo em C++, que sequência de valores serão impressos ? int x; x = 15; if (x > 0) { int x; x = 
25; cout << x << endl; } cout << x << endl; 
 
 
15 e 15 
 25 e 15 
 
15 e 25 
 
0 e 5 
 
25 e 25 
1a Questão (Ref.: 201201724218) Pontos: 0,1 / 0,1 
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. 
 
 
aluno.vet[10].nota=5.7; 
 
aluno.vet[10]=5.7; 
 
vet[10]=aluno.5.7; 
 
vet[10].aluno.nota=5.7 ; 
 vet[10].nota=5.7; 
 
 
 
 2a Questão (Ref.: 201201102205) Pontos: 0,1 / 0,1 
Diferentes tipos de estrutura de dados são adequadas a diferentes tipos de aplicação e algumas são altamente 
especializadas, destinando-se a algumas tarefas específicas. Dessa forma a definição de Estrutura de Dados está 
expressa na alternativa: 
 
 
É um modo de utilização de dados nos programas de computador. 
 
É um modo de distribuição e organização de dados em uma rede de computador de modo que possam 
ser usados de modo eficiente. 
 É um modo particular de armazenamento e organização de dados em um computador de modo que 
possam ser usados de modo eficiente. 
 
São os nomes dados as variáveis na montagem de uma rotina. 
 
É um modo de deleção de dados em um computador. 
 Gabarito Comentado. 
 
 
 
 3a Questão (Ref.: 201201724195) Pontos: 0,1 / 0,1 
As estruturas de dados podem ser caracterizadas como sendo uma forma organizada de armazenar dados ou 
informações na memória, de modo a otimizar o acesso a estes. Muitas vezes existem algoritmos de manipulação 
de dados associados a estas estruturas. 
Verifique as seguintes sentenças: 
I-Filas são estruturas que recuperam os dados na ordem direta em que estes foram armazenados. 
II-As Pilhas são estruturas que recuperam os dados na ordem reversa em que estes foram armazenados. 
III-As Pilhas são estruturas que recuperam os dados na ordem direta em que estes foram armazenados. 
IV-As Filas são estruturas que recuperam os dados na ordem reversa em que estes foram armazenados. 
Marque a alternativa CORRETA: 
 
 
Todas as alternativas estão corretas. 
 
As alternativas I e III estão corretas. 
 
As alternativas III e IV estão corretas. 
 As alternativas I e II estão corretas 
 
As alternativas II e IV estão corretas. 
 
 
 
 4a Questão (Ref.: 201201177789) Pontos: 0,1 / 0,1 
Sobre estrutura de dados, identifique o que está correto afirmar. 
I. Pilha é uma estrutura de dados com acesso restrito aos seus elementos, uma vez que eles são colocados e 
retirados por um único lado e são ordenados pelo princípio LIFO (last in first out). Assim, sempre que um 
elemento é adicionado ou retirado seu topo é alterado. 
II. Pilha é o tipo de estrutura usada, por exemplo, na avaliação de expressões numéricas, na recursividade e 
pelos compiladores, na passagem de parâmetros para as funções. 
III. Registro é uma estrutura básica que permite guardar coleções de dados de diferentes tipos, sendo 
normalmente utilizado quando um objeto tem diferentes atributos, isto é, contém campos de diferentes tipos. 
IV. Lista pode conter um número qualquer de elementos, expandindo-se ou contraindo-se conforme o 
elementos são inseridos ou retirados. Nesse tipo de estrutura, os acessos tanto podem ser feitos 
sequencialmente como diretamente. 
V. Fila, assim como a pilha , é uma versão especial de lista, e como tal, seus elementos são ordenados pelo 
princípio LIFO (last in first out). 
 
 I, II e III. 
 
II, IV e V. 
 
I, III e V. 
 
I, III, IV e V. 
 
II, III, IV e V. 
 Gabarito Comentado. 
 
 
 
 5a Questão (Ref.: 201201648741) Pontos: 0,1 / 0,1 
Leia com atenção as afirmativas abaixo e assinale a resposta correta. 
 
I A estrutura de dados que melhor representa os diretórios ou pastas de arquivos do computador é a árvore. 
II A estrutura de dados FILA é não linear assim como o Grafo. 
III O termo folha em uma estrutura de dados é usado para um nó sem filhos e que tem grau 0, 
IV O grau de uma árvore é definido pelo número de subárvores de um nó.V O grafo é uma estrutura de dados que tem limitação para o número de vértices. 
VI Uma das aplicações da estrutura de dados grafo é a Computação Gráfica. 
 
 II, IV e V são afirmativas verdadeiras 
 I, III, IV e VI são afirmativas verdadeiras 
 II, IV, V e VI são afirmativas verdadeiras 
 I, II e V são afirmativas verdadeiras 
 I, II, III e VI são afirmativas verdadeiras 
1a Questão (Ref.: 201201673748) Pontos: 0,1 / 0,1 
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 = 6 
 
 
0 
 
6 
 
4 
 3 
 
-1 
 
 
 
 2a Questão (Ref.: 201201826323) Pontos: 0,1 / 0,1 
Se i e j são variáveis int e p e q ponteiros para o tipo int, marque V para as opções verdadeiras e F para as 
opções ilegais 
 
 p= &*&i; 
 p= &i; 
 i = *&j 
 i= (*&)j 
 *q= &j; 
 
 
 
 3a Questão (Ref.: 201201758082) Pontos: 0,1 / 0,1 
Assinale a alternativa correta sobre tipos abstratos de dados: 
 
 Um tipo abstrato de dados é composto por um modelo de dados e um conjunto de operadores definidos 
sobre esses dados. 
 
É fundamental que os tipos abstratos de dados proponham um conjunto eficiente de algoritmos para 
realização de suas operações. 
 
Um tipo abstrato de dados é um modo particular de armazenamento e organização de dados em um 
computador de modo que possam ser usados eficientemente. 
 
Um tipo abstrato de dados descreve, além do que se pode fazer com os dados, como as operações serão 
efetivamente implementadas. 
 
Um tipo abstrato de dados deve sempre ser representado por meio dos recursos específicos de uma 
linguagem de programação. 
 
 
 
 4a Questão (Ref.: 201201673749) Pontos: 0,1 / 0,1 
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 = -6 
 
 -1 
 
6 
 
4 
 
3 
 
0 
 
 
 
 5a Questão (Ref.: 201201724220) Pontos: 0,1 / 0,1 
Entre os diversos algoritmos de pesquisa existentes, certamente os mais famosos são os da pesquisa sequencial 
e o da pesquisa binária. A busca ou pesquisa sequencial pode ser aplicada em vetores independente destes 
estarem ordenados, entretanto a busca binária só se aplica em vetores ordenados. Seja o vetor A= 
{10,35,41,55,69,70,98}, suponha que o número 70 foi pesquisado pelo algoritmo da busca sequencial e 
também pelo algoritmo da busca binária, ambos algoritmos realizam testes nos elementos do vetor até achar o 
que procuram ou definirem que o elemento não se encontra no vetor. Sendo assim marque a alternativa que 
expressa o número de testes realizados pela busca sequencial e o número de testes realizados pela busca 
binária, respectivamente, até encontrarem o 70. 
 
 
5 e 5 
 
7 e 1 
 
6 e 1 
 
6 e 4 
 6 e 2 
1a Questão (Ref.: 201201844355) Pontos: 0,0 / 0,1 
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 começo ou no fim, mas não no meio. 
 
Só poderei inserir no final da lista e nunca no começo ou 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 cheia. 
 Só poderei inserir no final da lista e no começo somente se ela estiver vazia. 
 
 
 
 2a Questão (Ref.: 201201680520) Pontos: 0,0 / 0,1 
 
 
 
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-1]= vet[j]; 
 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-1] < vet[j] ) 
 { 
 aux=vet[j]; 
 vet[j]= vet[j-1]; 
 vet[j-1]=aux; 
 } 
 
if(vet[j-1] > vet[j] ) 
 { 
 aux=vet[j]; 
 vet[j]= vet[j-1]; 
 vet[j-1]=aux; 
 } 
 
 
 
 3a Questão (Ref.: 201201816455) Pontos: 0,1 / 0,1 
Estava um aluno estudando Lista Simplesmente Encadeada quando encontrou em um site a 
definição da struct nodo e de uma função cujo nome você deverá escolher para substituir XXX 
nas opções abaixo depois que analisar a função, assumindo que teste foi realizado, 
permitindo que a operação fosse realizada. 
 
 struct nodo 
{ 
 int info; 
 struct nodo *prox; 
}; 
nodo* XXX(nodo *ptr, int valor) 
{ 
 nodo *temp = new nodo; 
 ... 
 temp->info = valor; 
 temp->prox = ptr; 
 return temp; 
} 
 
 ListaNo 
 RemoveNo 
 InsereNoFim 
 BuscaNaLista 
 InsereNoFrente 
 Gabarito Comentado. 
 
 
 
 4a Questão (Ref.: 201201110480) Pontos: 0,0 / 0,1 
Sobre o funcionamento da busca binária, é incorreto afirmar que dividindo seu vetor em duas metades. 
 
 
Se o item for menor ao item que está na primeira posição do vetor, o item não foi encontrado. 
 Se o item for igual ao item que está na metade do vetor, o item foi encontrado. 
 
Se o item for maior que o item que está na metade do vetor procure na segunda metade, ou seja, a da 
direita. 
 
Se o item for menor que o item que está na metade do vetor, procure na primeira metade, ou seja, a da 
esquerda. 
 Se o item for igual ao item que está na metade do vetor, o item não foi encontrado. 
 Gabarito Comentado. 
 
 
 
 5a Questão (Ref.: 201201772460) Pontos: 0,1 / 0,1 
Qual a estrutura de dados usada na implementação do método Round Robin do sistema operacional UNIX ? 
 
 Lista duplamente encadeada 
 
Lista simplesmente encadeada 
 
Fila 
 
Pilha 
 
Árvore 
 
DISCIPLINA : Estrutura de Dados
1ª. Lista de Exercícios 
Elaborada por Prof. Jane Tavares Alvarez da Silva
Funções e Operações com listas lineares seqüenciais
1) Considere o programa abaixo e depois dê o que se pede:
#include <iostream>
#include <cstdlib>
using namespace std;
void Teste1(int );
void Teste2(int &);
int Teste3(int);
int x = 20;
int main()
{
 int numero = 10, outroNumero;
 Teste1(numero);
 cout << "Valor de numero (após Teste1) = " << numero << endl; 
 cout << "X = " << x << endl; 
 
 Teste2(numero);
 cout << "Valor de numero (após Teste2) = " << numero << endl; 
 cout << "X = " << x << endl;
 
 outroNumero = Teste3(numero);
 cout << "Valor de outro numero (após Teste3) = " << outroNumero 
 << endl; 
 cout << "X = " << x << endl;
 
 system("pause");
 
}
void Teste1(int numero)
{
 numero = numero +x ;
 x++;
}
void Teste2(int &numero)
{
 int valor = 100;
 
 numero = numero + valor;
 x++;
}
int Teste3(int n)
{
 int valor = 200;
 n = n + valor;
 x--;
 return n;
} 
Pede-se:
a) Identifique as variáveis globais e locais. Quando identificar uma variável local, especifique 
o escopo da mesma.
b) Identifique, em cada função, o tipo de passagemde parâmetros.
c) Mostre, passo a passo, o valor de todas as variáveis, indicando o momento em que as 
variáveis não mais ocupam espaço na memória.
d) Diga o que é impresso na tela
Solução :
a)
Variável global : x
Variáveis locais : 
1) numero e outroNumero – escopo : main. 
Veja o trecho : 
 int main()
 {
 int numero = 10, outroNumero;
 //continua
2) numero - escopo : Teste1
3) numero e valor – escopo : Teste2
4) n e valor - escopo : Teste3
b)
Função main : Não há passagem de parâmetros
Função Teste 1 : Passagem de parâmetro por valor
Função Teste 2: Passagem de parâmetro por referência
FunçãoTeste 3: Passagem de parâmetro por valor
c) Ver com o professor(a).
d)
2) Considere listas lineares seqüenciais não ordenadas de inteiros não nulos. Faça um
programa para :
a) Construir duas listas sem repetição de dados. Para isto, implemente uma função de nome
inserirSemRepetir que receba como parâmetros: o vetor de dados, o elemento a ser inserido,
a quantidade de elementos no vetor e o tamanho máximo definido para o vetor. 
 Note :
 Deverão ser emitidas mensagens de erro adequadamente. 
 Será preciso fazer uma busca seqüencial para evitar repetição de dados. 
 A função deverá ser chamada repetidamente para criar cada uma das listas
b) Imprimir as listas criadas no item a), implementando uma função de nome percorrer,
conforme estudado em aula.
c) Intercalar as listas criadas, gerando uma terceira lista sequencial. Por exemplo, a 1ª.
lista possui os elementos 10, 34 e 5 e a 2ª. lista possui os elementos 4, 7 e 9. A lista
resultante será 10, 4,34,7,5 e 9.
d) Gerar uma lista que seja a interseção das listas do item a), como em interseção de
conjuntos.
e) Imprimir as listas geradas nos itens c) e d), usando a função percorrer.
f) Gerar uma lista que seja a união das listas do item a) e depois imprimi-la.
g) Remover um elemento da lista gerada no item f) através do índice passado. Para isto,
implemente uma função com o seguinte protótipo :
 void removerPeloIndice(int [], int &, int);
 Parâmetros :
- vetor de elementos
- quantidade de elementos no vetor
- índice do valor a ser removido
 Após a leitura do índice, verifique sua validade. Caso não seja válido, emita
mensagem de erro na main, caso contrário chame a função para realizar a remoção.
Solução :
#include <iostream>
using namespace std;
#define TAM 2
//Protótipos
void inserirSemRepetir(int [], int , int &, int ); 
void percorrer(int [], int);
int buscaSequencial(int [], int, int); 
void intercalar(int [], int [], int [], int, int, int &);
bool intersecao(int [], int [], int [], int , int , int &);
void uniao(int [], int [], int [], int , int , int &);
void removerPeloIndice(int [], int &, int);
//Prog. principal
int main()
{
 int v[TAM],
 w[TAM],
 z[2*TAM],
 inter[TAM],
 vetUniao[2*TAM],
 valor, // valor a ser inserido 
 nv, //quantidade de elementos em v
 nw, // quantidade de elementos em w
 nz,
 nUniao,
 ninter,
 posicao;
 //item a) Criar duas listas com elementos não nulos
 nv = nw = 0; //inicializa a quantidade de elementos das listas
 //Criar a 1a. lista com elementos não nulos
 cout << "\n\n############################################################\n\n";
 cout << "Criando a primeira lista : " << endl;
 while (true)
 {
 
 cout << "Digite um valor nao nulo : ";
 cin >> valor;
 if (valor > 0)
 {
 inserirSemRepetir(v,valor,nv,TAM);
 if (nv == TAM) //lista cheia
{ 
 cout << "Lista cheia. ";
 break;
}
 }
 else
 break;
 } // fim do while 
 //Criar a 2a. lista com elementos não nulos
 cout << "\n\n############################################################\n\n";
 cout << "Criando a segunda lista : " << endl;
 while (true)
 {
 
 cout << "Digite um valor nao nulo : ";
 cin >> valor;
 if (valor > 0)
 {
 inserirSemRepetir(w,valor,nw,TAM);
 if (nw == TAM)
 {
 cout << "Lista cheia. ";
 break;
 }
 }
 else
 break;
 } // fim do while 
 
 //item b) percorrer, ou seja, imprimir os dados de cada lista
 cout << "\nLista 1 : " ; //Poderia criticar se existe lista ou não
 percorrer(v,nv);
 cout << "\nLista 2 : "; //Poderia criticar se existe lista ou não
 percorrer(w,nw);
 //item c) intercalar
 nz = 0; //inicializa a quantidade de elementos em z
 intercalar(v,w,z,nv,nw,nz); //Poderia criticar se existe lista ou não
 cout << "\nLista resultante da intercalacao : " ;
 percorrer(z,nz); //item e)
 //item d) interseção
 ninter = 0;
 bool achou = intersecao(v,w,inter,nv,nw,ninter);
 
 cout << "\nVetor resultante da intersecao : "; 
 if (achou) //verifica se existe interseção
 percorrer(inter,ninter); //item e)
 else
 cout << "\nNao houve intersecao." << endl;
 //item f)uniao
 nUniao = 0;
 uniao(v,w,vetUniao,nv,nw,nUniao);
 if (nUniao != 0) //testa se existe uniao
 {
 cout << "\nVetor resultante da uniao : ";
 percorrer(vetUniao,nUniao);
 }
 else
 cout << "Lista uniao vazia. ";
 //item g) remover
 if (nUniao != 0)
 {
 do {
 cout << "\nDigite o indice do elemento a ser removido do vetor uniao : ";
 cin >> posicao;
 if (posicao < 0 || posicao >= nUniao)
 cout << "ERRO: Indice inexistente." << endl;
 } while (posicao < 0 || posicao >= nUniao);
 removerPeloIndice(vetUniao,nUniao, posicao);
 cout << "\nLista (uniao) apos remocao : "; //Poderia testar lista vazia
 percorrer(vetUniao,nUniao);
 }
 else
 cout << "\nImpossivel remover dado pelo indice da uniao, pois a lista 
uniao esta vazia. " << endl;
 cout << endl << endl;
 system("pause"); 
}
//Definições das funções
//Inserção no final da lista, pois não há ordem alguma.
// Note a passagem por referência - uso de &
void inserirSemRepetir(int v[], int valor, int &n, int tamanho) 
{
 int posicao; //testei lista cheia na main
 
 posicao = buscaSequencial(v,valor,n);
 if (posicao < 0)
 { 
 v[n] = valor; //insere na primeira posição livre
 n++; //ajusta a quantidade de elementos
 }
 else
 cout << "Nao havera insercao, pois o elemento ja existe na lista." 
 << endl;
 
 
}
//Impressão dos dados da lista
void percorrer(int v[], int n)
{
 for (int i = 0; i < n; i++)
 cout << " " << v[i];
}
// Busca sequencial
int buscaSequencial(int v[], int valor, int n)
{
for (int i = 0; i < n; i++)
{
if (v[i] == valor) //testa se achou
return i; //achou e retorna o índice do valor
}
 return -1; //fracasso - não achei o valor
}
//Intercalação para listas de tamanhos quaisquer
void intercalar(int v[], int w[], int z[], int nv, int nw, int &n)
{ 
int i;
for ( i = 0; i < nv && i < nw; i++)
{
z[i*2] = v[i];
z[i*2 + 1] = w[i];
n+=2;
}
 if (i == nw)
{
 for (int j = n; i < nv; j++,i++)
 {
z[j] = v[i];
n++;
 }
}
if (i == nv)
{
 for (int j = n; i < nw; i++, j++)
 {
 z[j] = w[i];
 n++;
 }
}
}
//Interseção
bool intersecao(int v[], int w[], int inter[], int nv , int nw , int &n)
{
 bool achou = false;
 for (int i = 0; i < nv; i++)
 for (int j = 0; j < nw; j++)
 if (v[i] == w[j])
 {
 inter[n] = v[i];
 achou = true;
 n++;
 }
 return achou;
}
void uniao(int v[], int w[], int u[], int nv, int nw , int &n)
{
bool diferentes= false;
 
 if (nv == 0) // se o vetor v está vazio, o resultado da uniao é o vetor w
 {
 for (int i = 0; i < nw; i++)
 u[i] = w[i];
 n = nw;
 return;
 }
 //se o vetor v não está vazio
 for (int i = 0; i < nv; i++) //copia todos os elementos de v para u
 u[i] = v[i];
 n = nv; 
 for (int i = 0; i < nw; i++) 
 {
for (int j = 0; j < nv; j++)
{
 if (w[i] != v[j])
 diferentes = true;
 else 
 {
 diferentes = false;
 break;
 }
}
 if (diferentes)
{
u[n] = w[i];
n++;
}
}
}
void removerPeloIndice(int u[], int &nUniao, int posicao)
{
u[posicao] = u[nUniao - 1];
nUniao--;
}
DISCIPLINA : Estrutura de Dados
1ª. Lista de Exercícios 
Elaborada por Prof. Jane Tavares Alvarez da Silva
Funções e Operações com listas lineares seqüenciais
1) Considere o programa abaixo e depois dê o que se pede:
#include <iostream>
#include <cstdlib>
using namespace std;
void Teste1(int );
void Teste2(int &);
int Teste3(int);
int x = 20;
int main()
{
 int numero = 10, outroNumero;
 Teste1(numero);
 cout << "Valor de numero (após Teste1) = " << numero << endl; 
 cout << "X = " << x << endl; 
 
 Teste2(numero);
 cout << "Valor de numero (após Teste2) = " << numero << endl; 
 cout << "X = " << x << endl;
 
 outroNumero = Teste3(numero);
 cout << "Valor de outro numero (após Teste3) = " << outroNumero 
 << endl; 
 cout << "X = " << x << endl;
 
 system("pause");
 
}
void Teste1(int numero)
{
 numero = numero +x ;
 x++;
}
void Teste2(int &numero)
{
 int valor = 100;
 
 numero = numero + valor;
 x++;
}
int Teste3(int n)
{
 int valor = 200;
 n = n + valor;
 x--;
 return n;
} 
Pede-se:
a) Identifique as variáveis globais e locais. Quando identificar uma variável local, especifique 
o escopo da mesma.
b) Identifique, em cada função, o tipo de passagem de parâmetros.
c) Mostre, passo a passo, o valor de todas as variáveis, indicando o momento em que as 
variáveis não mais ocupam espaço na memória.
d) Diga o que é impresso na tela
Solução :
a)
Variável global : x
Variáveis locais : 
1) numero e outroNumero – escopo : main. 
Veja o trecho : 
 int main()
 {
 int numero = 10, outroNumero;
 //continua
2) numero - escopo : Teste1
3) numero e valor – escopo : Teste2
4) n e valor - escopo : Teste3
b)
Função main : Não há passagem de parâmetros
Função Teste 1 : Passagem de parâmetro por valor
Função Teste 2: Passagem de parâmetro por referência
FunçãoTeste 3: Passagem de parâmetro por valor
c) Ver com o professor(a).
d)
2) Considere listas lineares seqüenciais não ordenadas de inteiros não nulos. Faça um
programa para :
a) Construir duas listas sem repetição de dados. Para isto, implemente uma função de nome
inserirSemRepetir que receba como parâmetros: o vetor de dados, o elemento a ser inserido,
a quantidade de elementos no vetor e o tamanho máximo definido para o vetor. 
 Note :
 Deverão ser emitidas mensagens de erro adequadamente. 
 Será preciso fazer uma busca seqüencial para evitar repetição de dados. 
 A função deverá ser chamada repetidamente para criar cada uma das listas
b) Imprimir as listas criadas no item a), implementando uma função de nome percorrer,
conforme estudado em aula.
c) Intercalar as listas criadas, gerando uma terceira lista sequencial. Por exemplo, a 1ª.
lista possui os elementos 10, 34 e 5 e a 2ª. lista possui os elementos 4, 7 e 9. A lista
resultante será 10, 4,34,7,5 e 9.
d) Gerar uma lista que seja a interseção das listas do item a), como em interseção de
conjuntos.
e) Imprimir as listas geradas nos itens c) e d), usando a função percorrer.
f) Gerar uma lista que seja a união das listas do item a) e depois imprimi-la.
g) Remover um elemento da lista gerada no item f) através do índice passado. Para isto,
implemente uma função com o seguinte protótipo :
 void removerPeloIndice(int [], int &, int);
 Parâmetros :
- vetor de elementos
- quantidade de elementos no vetor
- índice do valor a ser removido
 Após a leitura do índice, verifique sua validade. Caso não seja válido, emita
mensagem de erro na main, caso contrário chame a função para realizar a remoção.
Solução :
#include <iostream>
using namespace std;
#define TAM 2
//Protótipos
void inserirSemRepetir(int [], int , int &, int ); 
void percorrer(int [], int);
int buscaSequencial(int [], int, int); 
void intercalar(int [], int [], int [], int, int, int &);
bool intersecao(int [], int [], int [], int , int , int &);
void uniao(int [], int [], int [], int , int , int &);
void removerPeloIndice(int [], int &, int);
//Prog. principal
int main()
{
 int v[TAM],
 w[TAM],
 z[2*TAM],
 inter[TAM],
 vetUniao[2*TAM],
 valor, // valor a ser inserido 
 nv, //quantidade de elementos em v
 nw, // quantidade de elementos em w
 nz,
 nUniao,
 ninter,
 posicao;
 //item a) Criar duas listas com elementos não nulos
 nv = nw = 0; //inicializa a quantidade de elementos das listas
 //Criar a 1a. lista com elementos não nulos
 cout << "\n\n############################################################\n\n";
 cout << "Criando a primeira lista : " << endl;
 while (true)
 {
 
 cout << "Digite um valor nao nulo : ";
 cin >> valor;
 if (valor > 0)
 {
 inserirSemRepetir(v,valor,nv,TAM);
 if (nv == TAM) //lista cheia
{ 
 cout << "Lista cheia. ";
 break;
}
 }
 else
 break;
 } // fim do while 
 //Criar a 2a. lista com elementos não nulos
 cout << "\n\n############################################################\n\n";
 cout << "Criando a segunda lista : " << endl;
 while (true)
 {
 
 cout << "Digite um valor nao nulo : ";
 cin >> valor;
 if (valor > 0)
 {
 inserirSemRepetir(w,valor,nw,TAM);
 if (nw == TAM)
 {
 cout << "Lista cheia. ";
 break;
 }
 }
 else
 break;
 } // fim do while 
 
 //item b) percorrer, ou seja, imprimir os dados de cada lista
 cout << "\nLista 1 : " ; //Poderia criticar se existe lista ou não
 percorrer(v,nv);
 cout << "\nLista 2 : "; //Poderia criticar se existe lista ou não
 percorrer(w,nw);
 //item c) intercalar
 nz = 0; //inicializa a quantidade de elementos em z
 intercalar(v,w,z,nv,nw,nz); //Poderia criticar se existe lista ou não
 cout << "\nLista resultante da intercalacao : " ;
 percorrer(z,nz); //item e)
 //item d) interseção
 ninter = 0;
 bool achou = intersecao(v,w,inter,nv,nw,ninter);
 
 cout << "\nVetor resultante da intersecao : "; 
 if (achou) //verifica se existe interseção
 percorrer(inter,ninter); //item e)
 else
 cout << "\nNao houve intersecao." << endl;
 //item f)uniao
 nUniao = 0;
 uniao(v,w,vetUniao,nv,nw,nUniao);
 if (nUniao != 0) //testa se existe uniao
 {
 cout << "\nVetor resultante da uniao : ";
 percorrer(vetUniao,nUniao);
 }
 else
 cout << "Lista uniao vazia. ";
 //item g) remover
 if (nUniao != 0)
 {
 do {
 cout << "\nDigite o indice do elemento a ser removido do vetor uniao : ";
 cin >> posicao;
 if (posicao < 0 || posicao >= nUniao)
 cout << "ERRO: Indice inexistente." << endl;
 } while (posicao < 0 || posicao >= nUniao);
 removerPeloIndice(vetUniao,nUniao, posicao);
 cout << "\nLista (uniao) apos remocao : ";//Poderia testar lista vazia
 percorrer(vetUniao,nUniao);
 }
 else
 cout << "\nImpossivel remover dado pelo indice da uniao, pois a lista 
uniao esta vazia. " << endl;
 cout << endl << endl;
 system("pause"); 
}
//Definições das funções
//Inserção no final da lista, pois não há ordem alguma.
// Note a passagem por referência - uso de &
void inserirSemRepetir(int v[], int valor, int &n, int tamanho) 
{
 //FAZER !!
 
}
//Impressão dos dados da lista
void percorrer(int v[], int n)
{
 for (int i = 0; i < n; i++)
 cout << " " << v[i];
}
// Busca sequencial
int buscaSequencial(int v[], int valor, int n)
{
//FAZER
}
//Intercalação para listas de tamanhos quaisquer
void intercalar(int v[], int w[], int z[], int nv, int nw, int &n)
{ 
int i;
for ( i = 0; i < nv && i < nw; i++)
{
z[i*2] = v[i];
z[i*2 + 1] = w[i];
n+=2;
}
 if (i == nw)
{
 for (int j = n; i < nv; j++,i++)
 {
z[j] = v[i];
n++;
 }
}
if (i == nv)
{
 for (int j = n; i < nw; i++, j++)
 {
 z[j] = w[i];
 n++;
 }
}
}
//Interseção
bool intersecao(int v[], int w[], int inter[], int nv , int nw , int &n)
{
 //FAZER
}
void uniao(int v[], int w[], int u[], int nv, int nw , int &n)
{
bool diferentes = false;
 
 if (nv == 0) // se o vetor v está vazio, o resultado da uniao é o vetor w
 {
 for (int i = 0; i < nw; i++)
 u[i] = w[i];
 n = nw;
 return;
 }
 //se o vetor v não está vazio
 for (int i = 0; i < nv; i++) //copia todos os elementos de v para u
 u[i] = v[i];
 n = nv; 
 for (int i = 0; i < nw; i++) 
 {
for (int j = 0; j < nv; j++)
{
 if (w[i] != v[j])
 diferentes = true;
 else 
 {
 diferentes = false;
 break;
 }
}
 if (diferentes)
{
u[n] = w[i];
n++;
}
}
}
void removerPeloIndice(int u[], int &nUniao, int posicao)
{
u[posicao] = u[nUniao - 1];
nUniao--;
}
DISCIPLINA : Estrutura de Dados
4ª. Lista de Exercícios 
Elaborada por Prof. Jane Tavares Alvarez da Silva
Listas lineares sequenciais com structs
1) Escreva um programa em C++ que leia as informações de clientes de uma livraria (nome, código
de identificação do cliente, tipo de leitura preferido e telefone), guardando-as em um vetor de nome
CLIENTES, sem qualquer ordem. Seu programa deverá, após a criação do vetor, solicitar opções (via
teclado) que podem ser:
L (listar): nesse caso deverá ser também solicitado um tipo de leitura (C - Ciência, R - Romance, E -
Esoterismo ou O - Outros) e deverão ser listados todos os nomes e telefones de clientes que tenham
preferência por esse tipo;
O (ordenar): os clientes deverão ser ordenados pelo código de identificação. Obs: Essa opção só é válida
uma única vez;
B (buscar): deverá ser lida uma identificação e deverão ser mostrados o nome e o tipo de leitura preferida
do cliente. Caso ele não seja encontrado, apresente uma mensagem de aviso;
F (finalizar): o programa termina.
2) Escreva um programa em C++ que leia as informações de clientes de uma livraria (nome, código
de identificação do cliente, tipo de leitura preferido e telefone), guardando-as em um vetor ordenado de
nome CLIENTES. Seu programa deverá, após a criação do vetor, solicitar opções (via teclado) que
podem ser:
 
1- Ler uma identificação e buscar o cliente (usar busca binária);
2- Retirar um cliente
3- Listar todos os clientes
4- Terminar o programa 
GABARITO 
1)
#include <iostream>
#include <cctype>
using namespace std;
#define TAM 200 /* número máximo de clientes */
typedef struct {
 char nome[40],
 tipo, /* tipo de leitura : C, R ou ...*/
 tel[13];
 int codigo; /* código de identificação */
 
 } FICHA ;
 /* ---------------------------------------------------------------
 CÓDIGO DAS FUNÇÕES
------------------------------------------------------------------*/
 /* FUNÇÃO DE INCLUSÃO EM LISTA NÃO ORDENADA SEM REPETIÇÃO */
 int incluir (FICHA clientes[ ], FICHA f, int &pquant)
 {
 if (pquant == TAM)
 return 0 ; //sinaliza sinal de fracasso - lista cheia 
 clientes[pquant] = f; //atribui a struct inteira a primeira área livre do vetor 
 pquant++; 
 return 1; // sinaliza sucesso 
}
 /* BUSCA SEQUENCIAL PELO NÚMERO DE IDENTIFICAÇÃO */
int busca_sequencial(FICHA clientes[], int cod, int quant)
{
 int i ;
 for (i = 0; i < quant; i++)
 if (clientes[i].codigo == cod)
 return i; /* retorna o índice - valor de 0 em diante */
 return -1; /* retorna -1 caso não ache o código cod passado */
}
/* FUNÇÃO QUE REALIZA BUSCA PELO TIPO DE LEITURA */
void busca_sequencial_tipo(FICHA clientes[],char tipo, int quant_de_clientes)
{
 int i;
 bool achei = false; /* é falso que achei alguém do tipo passado */
 for (i = 0; i < quant_de_clientes; i++)
 if (clientes[i].tipo == tipo)
 {
 cout << "\n CLIENTE ... ";
 cout << "\n Nome : " << clientes[i].nome
 << "\n Telefone : " << clientes[i].tel;
 achei = true ; /* é verdade que achei alguém do tipo passado */
 }
 if (!achei)
 cout <<"\n Não foi encontrado cliente que goste do tipo indicado.";
}
/* FUNÇÃO QUE REALIZA BUSCA PELA IDENTIFICAÇÃO E IMPRIME OS DADOS PEDIDOS */
void busca_sequencial_codigo(FICHA clientes[],char cod,int quant_de_clientes)
{
 int i;
 bool achei = false; /* é falso que achei alguém do tipo passado */
 for (i = 0; i < quant_de_clientes; i++)
 if (clientes[i].codigo == cod)
 {
 cout << "\n CLIENTE ..."
 << "\n Nome : " << clientes[i].nome;
 switch(clientes[i].tipo)
 {
 case 'C' : cout << "\n Tipo de leitura : Ciencia" << endl;
 break;
 case 'F' : cout << "\n Tipo de leitura : Ficcao" << endl;
 break;
case 'E' : cout << "\n Tipo de leitura : Esoterismo" << endl;
 break;
case 'R' : cout << "\n Tipo de leitura : Romance" << endl;
 break;
case 'O' : cout << "\n Tipo de leitura : Outros" << endl;
 break;
 }
 achei = true ; /* é verdade que achei alguém do tipo passado */
 }
 if (!achei)
 cout <<"\n Cliente não cadastrado !";
}
void troca (FICHA v[], int i, int j) //Função para auxiliar a ordenação
{ 
FICHA aux;
aux = v[i];
v[i] = v[j];
v[j] = aux;
}
void ordenar(FICHA v[], int n) //Realiza a ordenação por seleção
{
 int i, j, menor;
 for (j = 0; j < n-1; j++)
 {
 menor = j;
 
 for (i = j+1; i < n; i++)
 if (v[i].codigo < v[menor].codigo)
 menor = i;
 
 troca(v, j, menor); // chamada para a função troca definida acima
 }
}
void listarClientes(FICHA v[], int n)
{
 for (int i = 0; i < n; i++)
 {
 cout << "\n CLIENTE ... ";
 cout << "\n Nome : " << v[i].nome
 << "\n Telefone : " << v[i].tel
 << "\n Codigo : " << v[i].codigo << endl;
 
 }
}
/*--------------------------------------------------------------
 PROGRAMA PRINCIPAL
---------------------------------------------------------------*/
void main(void)
{
 FICHA clientes[TAM], /* vetor para armazenar as fichas dos clientes */
 f ; /* uma ficha */
 int quant_de_clientes, /* quantidade de clientes */
 i , /* índice */
 sinal, /* sinal de sucesso ou fracasso */
 codigo ; 
 bool jaOrdenou = false;
 char resp, /* resposta para continuar ou não o cadastro*/
 tipo ; /* tipo de leitura preferida */
 cout <<"\t PROGRAMA PARA CADASTRAR CLIENTES E ... \n \n"; /* COMPLETE !! */
 quant_de_clientes = 0; /* inicializa a quantidade de clientes */
 for ( ; ; ) /* começa um loop quase infinito para cadastrar clientes */
 {
 do {
 printf ("\n Digite o código do cliente (valor maior que zero): ");
 cin >> f.codigo;
 i = busca_sequencial(clientes,f.codigo, quant_de_clientes);
 if (i >= 0)
 cout <<" \n Código já existente !";
 } while (i >= 0 || f.codigo <= 0);
 getchar(); //limpa o buffer
 cout << "\n Nome : ";
 gets(f.nome);
 cout << "\n Tel : ";
 gets(f.tel);
 cout << "\n Tipo de leitura preferida ..."
 << "\n Digite C (Ciência) ou R (Romance) ou E (Esoterismo) "
 << "\n ou F (Ficção) ou O (para outras preferências). ";
 cout <<"\n Tipo => ";
 f.tipo = toupper(getchar()); /* toupper converte para maiúscula */
 sinal = incluir(clientes, f, quant_de_clientes);
 if (!sinal) /* se sinal igual a zero significa lista cheia */
 {
 cout <<"\n Lista de clientes já está completa (cheia) !";
 break; /* sai do for */
 }
 cout <<"\n Deseja continuar cadastrando clientes ? \n Digite P para parar ou 
ENTER para continuar ";
 cout <<"\n Resposta => ";
 getchar();
 resp = toupper(getchar());
 if (resp == 'P')
 break;
 } /* fim do for */
 
 getchar();
 cout <<"\n\n**** MENU DE OPÇÕES ****\n" //Melhore, expondo este menu mais vezes 
 <<" Digite L para listar dados dos clientes segundo o tipo de leitura 
preferida.\n"
 <<" Digite O para ordenar as fichas dos clientes pelo código de 
identificação. \n"
 <<" Digite B para realizar uma busca pela identificação e mostrar ... \n"
 <<" Digite F para terminar o programa. \n"
 <<" Opção => ";
 resp = toupper(getchar());
 getchar();
 switch (resp)
 {
 case 'L' : cout <<"\n Digite o tipo de leitura preferida ... ";
 cout <<"\n C (Ciência)- R (Romance) - E (Esoterismo) ";
 cout <<"\n F (Ficção) - O (para outras preferências). ";
 cout <<"\n Tipo => ";
 tipo = toupper(getchar());
 busca_sequencial_tipo(clientes,tipo,quant_de_clientes); 
 break; /* sai do switch*/
 case 'O' : cout <<"\n Ordenando";
 if (!jaOrdenou){
 jaOrdenou = true;
 ordenar(clientes,quant_de_clientes);
 listarClientes(clientes,quant_de_clientes);
 }
 else
cout << "Lista de clientes já ordenadas.";
 
 break;
 case 'B' : do{
 cout <<"\n Digite um código de cliente que deseja pesquisar. ";
 cin >> codigo;
 } while (codigo <= 0); /* código válidos são maiores que zero */
 busca_sequencial_codigo(clientes,codigo,quant_de_clientes);
 break;
 case 'F' : cout <<"\n Fim do programa ! ";
 exit(0);
 default : cout <<"\n Digitou uma opção inválida !";
 
 } /* fim do switch */
 cout << endl << endl;
 } /* fim main */
2)
#include <iostream>
#include <cctype>
using namespace std;
#define TAM 200 //definindo uma constante
//Criando um tipo
 typedef struct {
 char nome[40],
 tipo, /* tipo de leitura : C, R ou ...*/
 tel[13];
 int codigo; /* código de identificação */
 
 } FICHA ;
 //Protótipos
int inserirOrdenada(FICHA [], FICHA , int &, int ); //não trabalha com repetição
bool buscaSequencialOrdenada(FICHA [], float, int &, int); 
void percorrer(FICHA [], int);
int buscaBinaria(FICHA [], int , int );
void removerOrdenada(FICHA [], int , int & );
//Prog. principal
int main()
{
FICHA clientes[TAM], 
 f; 
 char resp;
 int n, // número de elementos 
 codigo,
 sinal,
 opcao; // opção do menu
 n = 0; //inicializa a quantidade de elementos da lista
 cout << "\t\tCadastando clientes " << endl<< endl;
 for ( ; ; ) /* começa um loop quase infinito para cadastrar clientes */
 {
 cout << "Cliente " << (n+1) << " : " << endl; 
 cout << "\n Digite o codigo do cliente (valor maior que zero): ";
 cin >> f.codigo;
 getchar();
 cout << "\n Nome : ";
 gets(f.nome);
 cout << "\n Tel : ";
 gets(f.tel);
 cout << "\n Tipo de leitura preferida ..."
 << "\n Digite C (Ciência) ou R (Romance) ou E (Esoterismo) "
 << "\n ou F (Ficção) ou O (para outras preferências). ";
 cout <<"\n Tipo => ";
 f.tipo = toupper(getchar()); /* toupper converte para maiúscula */
 sinal = inserirOrdenada(clientes,f,n,TAM); 
 if (sinal == -1) /* se sinal igual a zero significa lista cheia */
 {
 cout <<"\n Lista de clientes já está completa (cheia) !";
 break; /* sai do for */
 }
 else
 if (sinal == 0)
 cout << "Cliente ja cadastrado. " << endl;
 cout <<"\n Deseja continuar cadastrando clientes ? \n Digite P para parar ou 
ENTER para continuar ";
 cout <<"\n Resposta => ";
 getchar();
 resp = toupper(getchar());
 if (resp == 'P')
 break;
 cout << endl;
 } /* fim do for */
 while (true)
 {
 cout << "\n\n############################################################\n\n";
 cout << "\t\t\t Menu" << endl << endl;
 cout << "1- Buscar cliente pelo codigo(busca binaria) \n2- Remover cliente pelo 
codigo(remocao ordenada) "
 << "\n3- Percorrer a lista de clientes"
 << "\n4- Terminar o programa " << endl << endl;
 cout << "Opcao = > ";
 cin >> opcao;
 
 switch (opcao)
 {
 case 1 : 
 int posicao;
 cout << "Codigo do cliente a ser procurado ? ";
 cin >> codigo;
 posicao = buscaBinaria(clientes,codigo,n);
 if (posicao < 0)
 cout << "Cliente nao encontrado. " << endl;
 else
 cout << "Cliente " << clientes[posicao].nome 
 << " encontrado. " << endl;
 
 break;
 
 case 2 : cout << "Forneca o codigo do cliente a ser removido : ";
 cin >> codigo;
 removerOrdenada(clientes,codigo,n);
 break;
 
 
 case 3 : cout << "\nLista resultante: " << endl;
 percorrer(clientes,n); // a lista possui n elementos
 break;
 
 case 4 : cout << "\n\a\aFIM DO PROGRAMA." << endl << endl;
 break;
 
 default : //será a última opção sempre. Não se esqueça !!!
 cout << "ERRO : opcao invalida." << endl;
 
 } //fim do switch
 
 if (opcao == 4)
 break; //sai do while
 } // fim do while 
 
 
 system("pause"); 
}
// Definições das funções
bool buscaSequencialOrdenada(FICHA v[], int cod, int & pos, int n)
{
 int i;
 
 for (i = 0; i < n && cod > v[i].codigo;i++);
 pos = i;
 if (i == n || cod != v[i].codigo)
 return false;
 return true;
}
// Inserção de forma ordenada - mantém a ordem crescente dos dados pelos códigos.
// Note que a inserção é sem repetição. 
//Portanto, não será inserido cliente já existente na lista.
int inserirOrdenada(FICHA v[], FICHA f, int &n, int tamanho) 
{
 int posicao;
 
 if (tamanho == n) // testa se a lista está cheia
 {
 return -1; // sai da função – retorna sinal de fracasso
 }
 if (buscaSequencialOrdenada(v,f.codigo,posicao, n) == true) 
 {
 return 0; //sai da função – outro sinal de fracasso
 }
 // Se a função não terminar com qualquer return acima, teremos mesmo
 // assim, a posição de inserção armazenada na variável posicao
 // Logo abaixo, posicao representa a posição onde o valor deveria 
 // estar na lista, mas não está.
 
 for (int i = n; i > posicao; i--)
 v[i] = v[i-1]; 
 
 v[posicao] = f;
 n++;
 return 1;
 
 
}
//Impressão dos dados da lista - não importa se a lista está ou não ordenada
void percorrer(FICHA v[], int n)
{
 for (int i = 0; i < n; i++)
 {
 cout << "Codigo : " << v[i].codigo << endl
 << "Nome : " << v[i].nome << endl << endl
<< "Telefone : " << v[i].tel << endl;
 // Coloque a impressão do tipo de leitura
 }
}
// Busca binária - apenas para listas ordenadas
int buscaBinaria(FICHA v[], int codigo, int n)
{
 
 int ini = 0, fim = n-1, meio;
 
 while (ini <= fim)
 {
 meio = (ini + fim) / 2;
 if (v[meio].codigo == codigo)
 return meio; 
 
 if (codigo < v[meio].codigo)
 fim = meio - 1;
 else
 ini = meio + 1;
 }
 return -1; 
}
 
 
//Remoção Ordenada
void removerOrdenada(FICHA v[], int codigo, int& n)
{
 int posicao; 
 
 if (n == 0)
 {
 cout << "Lista vazia." << endl;
 return; //sai da função
 }
 if (buscaSequencialOrdenada(v,codigo,posicao,n) == false)
 {
 cout << codigo << " não encontrado. Cliente inexistente. " << endl;
 return; //sai da função
 }
 
 n--; //decrementa a quantidade de fichas 
 for (int i = posicao; i < n; i++)
 v[i]= v[i+1];
 cout << "Sucesso na remoção. " << endl;
 
 
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Ponteiro
3) Considere 
struct caixa {
 char c; // refere-se a cor : P (preta) ou B (branca) 
 float preco;
 } ;
caixa *p, *q, *r;
caixa x, y, z;
Assinale V (verdadeiro) ou F (falso). Caso seja verdadeiro, exemplifique com ilustração gráfica,
mas se for falso, reescreva uma possível forma correta.
a) r = &x;
b) p = r;
c) q = y;
d) r = NULL;
e) p = *x;
f) *q = NULL;
g) *p = *x;
h) z.c = ‘B’;
i) rpreco = 12.99;
j) p.preco = 99.99;
k) (*p)c = ‘P’;
GABARITO 
a) (V)
 x
 r
b) (V)
 x
 r p
c) (F) CERTO : q = &y;
d) (V)
 
e) (F) CERTO : p = &x;
f) (F) CERTO: q = NULL;
g) (F) CERTO : *p = x;
h) (V) z B 
i) ( V )
 12.99 
 
 r p 
j) ( F) CERTO : ppreco = 99.99;
k) (F) CERTO : pc = ‘P’;
DISCIPLINA : Estrutura de Dados – Professora : Jane
GABARITOS
AULA 1 : FEITO EM AULA, no quadro. Por favor, pegue com quem estava em 
aula.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
AULA 2 : Faça um programa que crie uma lista de inteiros distintos, através de 
sucessivas inserções e depois a apresente na saída padrão. 
 Implemente funções para :
 è Inserir um valor, sem que haja repetição. Para isto, será preciso fazer uma 
busca seqüencial e inserir o valor passado apenas se o mesmo não for encontrado 
na lista. Seja void inserirSemRepetir(int [], int , int &, int); 
 Parâmetros: Vetor de dados, elemento a ser inserido, quantidade de dados 
existentes no vetor e a quantidade máxima alocada para o vetor.
 Obs.: Obs.: A função buscarSequencial deverá ser chamada dentro da 
 inserirSemRepetir e consequentemente, implementada no programa
 è Percorrer a lista, imprimindo-a na saída padrão. 
 Seja void percorrer(int [], int ); // Receberá o vetor e a quantidade de dados
Solução :
#include <iostream>
using namespace std;
#define TAMANHO 5 //define uma constante TAMANHO que vale 5
//Protótipos
void percorrer(int v[], int n);
void inserirSemRepeticao(int v[], int valor, int &n, int tamanho);
int buscaSequencial(int v[], int valor, int n);
//Prog. principal
int main()
{
 int v[TAMANHO],
 valor, //valor a ser inserido em v
 n, //quantidade de elementos existentes no vetor v
 posicao; //armazena o inteiro retornado pela função buscaSequencial
 char resposta;
 
 cout << "CRIANDO UMA lista sequencial COM NO MAXIMO " 
 << TAMANHO << " ELEMENTOS." << endl;
 
 n = 0; //iniciliza a quantidade de elementos em v
 while (true)
 {
 cout << "Digite um valor : ";
 cin >> valor;
 inserirSemRepeticao(v,valor,n,TAMANHO); //chama a função 
 if (n == TAMANHO)
 {
 cout << "AVISO : Lista cheia. " << endl;
 break; //sai do while
 }
 cout << "Deseja parar ? Digite P/p para parar ou C/c para continuar ===>>> ";
 getchar(); //limpa o buffer 
 cin >> resposta;
 if (resposta == 'P' || resposta == 'p')
 break; //sai do while
 } //fim do while
 
 cout << "\n\nImprimindo os dados da lista sem repeticoes : ";
 percorrer(v,n); //chama a função percorrer
 
 cout << endl;
 system("pause");
 
} //fim do programa principal
//Definições das funções
void percorrer(int v[], int n)
{
 for (int i = 0; i < n; i++)
 cout << " " << v[i];
}
int buscaSequencial(int v[], int valor, int n)
{
 for (int i = 0; i < n; i++)
 if (v[i] == valor) //testa se o valor está em v
 return i; //retorna o índice do valor em v e sai da função
 //Note que dentro do for só existe o if e dentro do if só existe o return i;
 return -1; //sai da função retornando um valor impossível para índice. 
}
void inserirSemRepeticao(int v[], int valor, int &n, int tamanho)
{
 int posicao;
 
 if (n == tamanho)
 return; //sai da função - lista cheia
 
 posicao = buscaSequencial(v,valor,n);
 if (posicao < 0) //se não achou o valor em v
 {
 v[n] = valor; // insere no final, visto que não ordem.
 n++; // ajusta a quantidade de elementos em v
 }
 else
 cout << "ERRO: Valor ja existente. " << endl;
 
}
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
AULA 3 : Crie uma lista não ordenada de inteiros, ordene-a pelo bubblesort e 
depois ofereça um menu com as opções : 
 1- inserir em lista ordenada 
 2-remover de lista ordenada 
 3- pesquisa binária 
 4 - apresentar os dados da lista 
 5- terminar o programa. 
 Considerações :
 è Implementar uma função para cada operação indicada no menu.
è Após a implementação e teste do programa, você poderá melhorá-lo, fazendo o 
menu se repetir várias vezes. (em casa)
è Não se esqueça de emitir mensagens de erro para as situações críticas, como 
por exemplo, lista vazia e lista cheia, entre outras.
Solução :
#include <iostream>
using namespace std;
#define TAM 10
//protótipos
bool inserirSemOrdem(int [], int , int &, int );
bool inserirOrdenada(int [], int , int &, int );
bool removerOrdenada(int [], int , int &);
int buscaBinaria(int [], int , int);
void imprimir(int [], int);
void bubblesort(int [], int );
//////////////// Programa principal /////////////////////////////////////////
int main()
{
 int v[TAM], //declara um vetor com capacidade para TAM elementos inteiros
 n , // quantidade de dados em v
 valor, // valor para inserção
 opcao, // opção do menu
 posicao; //variavel que armazenará o retorno da busca
 
 char resposta; //indica se continuará criando a lista ou não
 bool sinal; //serve para sinalizar se houve ou não inserção ou remoção 
 
 n = 0; // inicializa a quantidade de dados da lista
 cout << "\tCRIANDO UM VETOR DE ELEMENTOS INTEIROS QUAISQUER 
SEM ORDEM ALGUMA" << endl;
 while (true) {
 cout << "\nValor para insercao (sem ordem) ? ";
 cin >> valor;
 sinal = inserirSemOrdem(v,valor,n,TAM);
 if (sinal == false) //indica lista cheia - é falso que inseriu
 break; //sai do while se a lista estiver cheia
 getchar(); //limpa o buffer de entrada 
 cout << "Digite P/p para PARAR ou C/c para CONTINUAR => ";
 cin >> resposta; 
 if (resposta == 'P' || resposta == 'p')
 break;
 } //fim do while
 cout << "\nOrdenando a lista pelo bubblesort .... " << endl;
 bubblesort(v,n);
 
 do {
 cout << "\n################################################# " 
 << endl << endl;
 cout << "\t\t\tMENU" << endl;
 cout << "1 - Inserir ordenada \n2 - Remover Ordenada \n3 - Pesquisa 
binaria " << "\n4 - Apresentar os dados da lista \n5 - Terminar o programa. " 
 << endl;
 cout << "\nOPCAO => ";
 cin >> opcao;
 switch (opcao) {
 case 1 : cout << "Inserindo em lista ja ordenada ... " << endl;
 cout << "Digite um valor para adicionar à lista : ";
 cin >> valor;
 sinal = inserirOrdenada(v,valor, n, TAM);
 if (sinal == false)
 cout << "ERRO : insercao com fracasso. " << endl;
 break;
 case 2 : cout << "Removendo de lista ordenada .... " << endl;
 cout << "Digite um valor remover da lista : ";
 cin >> valor;
 sinal = removerOrdenada(v,valor, n);
 if (sinal == false)
 cout << "ERRO : remocao com fracasso. " << endl;
 break;
 
 case 3 : cout << "Digite um valor para busca : ";
 cin >> valor;
 posicao = buscaBinaria(v,valor,n);
 if (posicao < 0)
 cout << "\nERRO : " << valor << " nao encontrado. " << endl;
 else
 cout << "\nEncontrado o valor " << valor << " na posicao " 
 << posicao << endl;
 break; // sai do switch
 
 case 4: cout << "\nDados da lista : " << endl;
 imprimir(v,n);
 break;
 case 5 : cout << "\nFIM DO PROGRAMA." << endl << endl;
 break;
 
 default : cout << "ERRO : Opcao invalida. " << endl; 
 
 } //fim do switch
 } while (opcao != 5);
 
 cout << endl << endl;
 system("pause");
}// FIM DA MAIN
//Definições das funções 
bool inserirSemOrdem(int v[], int valor, int &n, int tamanho) 
{
 if (tamanho == n)
 {
 cout << "ERRO: Lista cheia.";
 return false; //sinaliza lista cheia
 }
 else
 {
 v[n] = valor; //ADICIONA NO FIM DO VETOR
 n++; //ajusta a quantidade de elementos no vetor
 return true; //sinaliza lista não cheia
 }
} 
bool inserirOrdenada(int v[], int valor, int &n, int tam) 
{ 
 int i, posicao;
 
 if(n == tam) // testa se o vetor está cheio
 {
 cout << "ERRO : Lista cheia." << endl;
 return false; // entenda o uso de return desta forma
 }
 // Procura a posição de inserção
 i = 0;
 while (valor > v[i] && i < n)
 i++;
 // armazena a posição onde o valor deverá ser armazenado
 posicao = i; 
 // Desloca os elementos, mantendo a ordem
 for (i = n; i > posicao; i--)
 v[i] = v[i-1];
 // Insere na posição de inserção
 v[posicao] = valor;
 // Incrementa a quantidade
 n++;
 return true;
 }
bool removerOrdenada(int v[], int valor, int &n) { 
 int i, posicao;
 
 if (n == 0) // testa se o vetor está vazio
 {
 cout << "ERRO : Lista vazia." << endl;
 return false; 
 }
 posicao = buscaBinaria(v,valor,n); //chamada para a busca binária
 if (posicao < 0) {
 cout << "ERRO : Elemento não encontrado." << endl;
 return false;
 }
 // decrementa a quantidade de elementos da lista, já que 1 sairá
 n--; 
 // desloca os elementos, ajustando a lista
 for (i = posicao; i < n; i++) 
 v[i] = v[i+1];
 return true;
}
int buscaBinaria(int v[], int valor, int n) {
 int ini = 0, // inicializa o início do intervalo para a busca
 fim = n -1, // inicializa o fim da intervalo
 meio; // armazenará o índice do meio do intervalo
 while (ini <= fim)
 {
 meio = (ini + fim)/2; // determina o meio do intervalo
 if (v[meio] == valor) //testa se o valor está no meio do vetor
 return meio; 
 if (valor < v[meio]) //testa se o valor vem antes do meio do vetor
 fim = meio -1; //redefine o fim, caso o valor possa estar antes do meio
 else
 ini = meio+1; //redefine o ini, caso o valor possa estar depois do meio
 }
 return -1; // não achou o valor no vetor 
}
void imprimir(int v[], int n)
{
 for (int i = 0; i < n; i++)
 cout << " " << v[i];
}
// ordenaçãovoid bubblesort(int v[], int n) // n é o no. de elementos em v
{ int i , // índice
 fim = n - 1,
 aux; //auxiliar para troca
 bool trocou = true; // é verdade que trocou - artifício para entrar no loop
 while (trocou) {
trocou = false; // sinaliza que é falso que trocou
for (i = 0; i < fim; i++) {
if (v[i] > v[i+1])
{
aux = v[i];
 v[i] = v[i+1];
 v[i+1] = aux;
trocou = true; 
 } // fim if
 } // fim for
 fim--; // decrementa o fim
} // fim while
} // fim da função
AULA 4 : Use seu programa anterior (aula 3 - anterior) e ofereça um menu com as 
seguintes opções :
 1 – Ordenação por troca (Bubblesort)
 2- Ordenação por seleção
 3- Ordenação por inserção
 Dessa forma, o usuário poderá escolher a ordenação antes de ir para o 2º. 
Menu.
 Note que, uma vez escolhido o método de ordenação, a função adequada 
deverá ser chamada e executada. Ao final, exiba a lista ordenada pelo método 
escolhido.
 
Solução :
 Para a solução desta tarefa, pegue todo o programa da aula 3 e acrescente o 
que for indicado a seguir :
 Nos protótipos, adicione :
void ordenaSelecao(int v[], int n) ;
void ordenaInsercao(int v[], int n);
 Nas definições das funções, adicione :
void ordenaInsercao(int v[], int n) // n é o número de elementos em v 
{ int i, j, aux;
 for (j = 1; j < n; j++)
 for (i=j; i > 0 && v[i-1]> v[i]; i--)
 { 
 aux = v[i-1];
 v[i-1] = v[i];
 v[i] = aux;
 } 
}
 void ordenaSelecao(int v[], int n) {
 int i, j, menor, aux;
 for (j = 0; j < n-1; j++)
 {
 menor = j;
 for (i = j+1; i < n; i++)
 if (v[i] < v[menor])
 menor = i;
 aux = v[j];
 v[j] = v[menor];
 v[menor] = aux;
 }
}
 Dentro da main, substitua o trecho 
 cout << "\nOrdenando a lista pelo bubblesort .... " << endl;
 bubblesort(v,n);
por :
int ordenou;
cout << "\n################################################# " 
 << endl << endl;
 cout << "\t\t\tMENU 1 : ESCOLHENDO UMA ORDENACAO" << endl;
 cout << "1 - BUBBLESORT \n2 - ORDENACAO POR INSERCAO \n3 - 
ORDENACAO POR SELECAO." << endl;
 cout << "\nOPCAO => ";
 cin >> opcao;
 
 ordenou = 0; //sinaliza que nao houve ordenação 
 switch (opcao)
 {
 case 1 : cout << "Ordenando por trocas ... metodo bubblesort " 
 << endl;
 bubblesort(v,n);
 ordenou = 1; //sinaliza que houve ordenação
 break;
 case 2 : cout << "Ordenacao por insercao " << endl;
 ordenaInsercao(v,n); 
 ordenou = 1; //sinaliza que houve ordenação
 break;
 case 3 : cout << "Ordenacao por selecao " << endl;
 ordenaSelecao(v,n);
 ordenou = 1; //sinaliza que houve ordenação
 break;
 
 default : cout << "AVISO : NENHUMA ORDENACAO SELECIONADA. 
" << endl;
 } //fim do switch
 
 No case 3 (2º. Menu) , adicione o trecho em azul :
 case 3 : 
 if (ordenou == 1) //se é verdade que ordenou
 {
 cout << "Digite um valor para busca : ";
 cin >> valor;
 posicao = buscaBinaria(v,valor,n);
 if (posicao < 0)
 cout << "\nERRO : " << valor << " nao encontrado. " << endl;
 else
 cout << "\nEncontrado o valor " << valor << " na posicao " 
 << posicao << endl;
 }
 else
 cout << "ERRO : a lista não foi ordenada. "<< endl;
 break; // sai do switch
Aviso geral : Se achar necessário, use este mesmo raciocínio para 
algum outro trecho do programa, ok ?
DISCIPLINA : Estrutura de Dados
3ª. Lista de Exercícios 
Elaborada por Prof. Jane Tavares Alvarez da Silva
FILA
 FILA SEQUENCIAL SIMPLES
1) Faça um programa em C++ para apresentar um menu várias vezes, com as seguintes
opções : 
 MENU
1- Enfileirar um número inteiro positivo.
2- Desenfileirar tudo e imprimir apenas os valores que são múltiplos de 5.
3- Terminar o programa
 
 Implemente, adequadamente, cada opção fornecida.
2) Faça um programa em C++ para ler uma sequência de caracteres (vetor de char) e
enfileirá-los. Em seguida, desenfileire todos os caracteres e empilhe-os em uma pilha P
seguindo as orientações:
 Converta as letras para maiúsculas antes de empilhá-las
 Qualquer outro caracter, empilhe sem alteração. 
Ao final, desempilhe tudo, exibindo o resultado na saída padrão.
 FILA SEQUENCIAL CIRCULAR
3) Faça um programa em C++ para apresentar um menu várias vezes, com as seguintes
opções : 
 MENU
1- Enfileirar um valor inteiro não nulo
2- Desenfileirar um valor, exibindo na tela o seu dobro 
3- Desenfileirar tudo, exibindo os valores desenfileirados sem alterações
4- Terminar o programa
 
 Implemente, adequadamente, cada opção fornecida usando funções para enfileirar e
desenfileirar.
4) Faça um programa que leia um vetor de char e enfileire seus dados em duas filas : fila A
(fila simples – de char ) e fila B (fila circular com contador – de inteiros) da seguinte forma:
 Se o caracter for dígito, converta-o para dígito e enfileire-o em B.
 Se o caracter for letra, enfileire-o em A.
 Qualquer outro caracter não deverá ser enfileirado.
Ao final, desenfileire as filas B e A, nesta ordem, exibindo os seus dados. 
DISCIPLINA : Estrutura de Dados
4ª. Lista de Exercícios 
Elaborada por Prof. Jane Tavares Alvarez da Silva
Listas lineares sequenciais com structs
1) Escreva um programa em C++ que leia as informações de clientes de uma livraria (nome, código
de identificação do cliente, tipo de leitura preferido e telefone), guardando-as em um vetor de nome
CLIENTES, sem qualquer ordem. Seu programa deverá, após a criação do vetor, solicitar opções (via
teclado) que podem ser:
L (listar): nesse caso deverá ser também solicitado um tipo de leitura (C - Ciência, R - Romance, E -
Esoterismo ou O - Outros) e deverão ser listados todos os nomes e telefones de clientes que tenham
preferência por esse tipo;
O (ordenar): os clientes deverão ser ordenados pelo código de identificação. Obs: Essa opção só é válida
uma única vez;
B (buscar): deverá ser lida uma identificação e deverão ser mostrados o nome e o tipo de leitura preferida
do cliente. Caso ele não seja encontrado, apresente uma mensagem de aviso;
F (finalizar): o programa termina.
2) Escreva um programa em C++ que leia as informações de clientes de uma livraria (nome, código
de identificação do cliente, tipo de leitura preferido e telefone), guardando-as em um vetor ordenado de
nome CLIENTES. Seu programa deverá, após a criação do vetor, solicitar opções (via teclado) que
podem ser:
 
1- Ler uma identificação e buscar o cliente (usar busca binária);
2- Retirar um cliente
3- Listar todos os clientes
4- Terminar o programaPonteiro
3) Considere 
struct caixa {
 char c; // refere-se a cor : P (preta) ou B (branca) 
 float preco;
 } ;
caixa *p, *q, *r;
caixa x y, z;
Assinale V (verdadeiro) ou F (falso). Caso seja verdadeiro, exemplifique com ilustração gráfica,
mas se for falso, reescreva uma possível forma correta.
a) r = &x;
b) p = r;
c) q = y;
d) r = NULL;
e) p = *x;
f) *q = NULL;
g) *p = *x;
h) z.c = ‘B’;
i) rpreco = 12.99;
j) p.preco = 99.99;
k) (*p)c = ‘P’;
DISCIPLINA : Estrutura de Dados
5ª. Lista de Exercícios 
Elaborada por Profa Jane Tavares Alvarez da Silva
Listas Lineares Simplesmente Encadeadas 
(não circulares)
Faça um programa em C++ com listas simplesmente encadeadas de inteiros, em que seja
solicitada uma quantidade n de nós para a lista. Note que n deve ser um número maior ou igual
a zero .
Após esta entrada, faça o que se pede:
1) Escreva uma função em C++ para inserir um valor inteiro no início da lista. Esta função
deverá ser chamada na main, de dentro de um loop, para que seja construída uma lista
com n nós. Não se esqueça de inicializar a lista.
 Protótipo da função : no* insereFrente(no *, int );
 Parâmetros : Ponteiro para o início da lista e o valor inteiro a ser inserido ou adicionado.
 Retorno : Ponteiro para o início da lista
2) Escreva uma função em C++ para percorrer uma lista simplesmente encadeada e imprimir
na tela, todos os seus dados.
 Protótipo da função : void imprimir(no *);
 Parâmetro : Ponteiro para o início da lista
 Retorno : Não há
3) Escreva uma função em C++ para substituir o valor de um nó passado, por um novo valor
também informado. Considerando que o 1º. nó é o nó 1, o 2º. nó é o nó 2 e assim,
sucessivamente, deverão ser passados como parâmetros : o ponteiro para o início da lista, o
no. do nó que sofrerá a substituição e o novo valor. Note que, esta função não retornará valor
algum.
Considere que ao ser lido, na main, o no. do nó que sofrerá a substituição, este no. deverá
ser criticado/testado para que a função somente seja chamada quando o número do nó for
maior que zero e menor ou igual que a quantidade de nós da lista.
 Protótipo da função : void substituir(no *, int , int novoValor);
4) Escreva uma função em C++ para remover o 1º. nó de uma lista simplesmente
encadeada não vazia, eliminando-o. Teste, na main, se a lista está vazia e emita
mensagem adequada para este caso.
Parâmetro: ponteiro para o início da lista
Retorno : ponteiro para a lista
Note que, neste exercício, não se está interessado no valor armazenado no nó
removido, que deve ser eliminado.
5) Escreva uma função em C++ para realizar uma busca ou pesquisa seqüencial na lista,
retornando NULL (fracasso na busca) ou o endereço do nó com o valor encontrado
(sucesso na busca).
Parâmetros: ponteiro para o início da lista e valor a ser procurado
Retorno : NULL (fracasso na busca) ou o endereço do nó com o valor encontrado
(sucesso na busca).
Note que, neste exercício, não se está interessado no valor armazenado no nó
removido, que deve ser eliminado.
 
6) Faça uma função em C++ para contar o número de nós de uma lista simplesmente
encadeada qualquer, ou seja, a lista pode estar vazia ou não.
Protótipo : int contaNos(no *);
Retorno : A quantidade de nós da lista, que pode ser zero.
7) Escreva uma função em C++ para inserir um valor inteiro no fim da lista. Esta função
deverá ser chamada na main de dentro de um loop, para que seja construída uma lista
com m nós. Não se esqueça de ler a quantidade m de nós e de inicializar a lista.
Note que, m dever ser maior ou igual a zero .
 Protótipo da função : no* insereFim(no *, int );
 Parâmetros : Ponteiro para o início da lista e o valor inteiro a ser inserido (ou adicionado).
 Retorno : Ponteiro para o início da lista
8) Escreva uma função em C++ para remover o último nó de uma lista. 
 Protótipo da função : no* removeFim(no *);
 Parâmetros : Ponteiro para o início da lista 
 Retorno : Ponteiro para a lista
9) Escreva uma função em C++ para concatenar as duas listas construídas até agora,
colocando a lista com m nós no final da lista com n nós. 
 Protótipo : no *concatena(no *, no *);
 Parâmetros : Ponteiro para o início da 1ª. lista (que pode ser NULL) e ponteiro para o início
da 2ª. lista (que pode ser NULL).
 Retorno : Ponteiro para o início da lista resultante da concatenação
Após a chamada desta função na main, imprima os dados da lista resultante da
concatenação.
DISCIPLINA : Estrutura de Dados
6ª. Lista de Exercícios 
Elaborada por Profa Jane Tavares Alvarez da Silva
Fila dinâmica 
1. Faça um programa em C++ para criar uma fila dinâmica de inteiros positivos, através de
sucessivas inserções ou enfileiramentos. Ao ser digitado um valor negativo ou nulo, a criação da
fila deverá ser encerrada. Não esqueça de tratar fila vazia.
 Após a criação da fila, faça o que se pede :
a) Imprima na tela os dados da fila.
b) Desenfileire um valor, apresentando-o na tela, após a mensagem “Elemento desenfileirado “. 
c) Conte o número de dados da fila.
d) Desenfileire tudo, apresentando na tela apenas os dados pares.
2. Faça um programa em C++ para ler a quantidade n de alunos de uma fila dinâmica, sendo que
cada aluno é caracterizado pela matrícula (int) e pela média. Uma vez determinado n, que deve
ser maior ou igual a zero, enfileire n alunos, solicitando seus dados. Logo em seguida, faça o
que se pede :
a) imprima todos os dados, de todos os alunos.
b) desenfileire todos os alunos, imprimindo na tela a matrícula dos que possuem média
superior ou igual a 5. 
DISCIPLINA : Estrutura de Dados
7ª. Lista de Exercícios 
Elaborada por Profa Jane Tavares Alvarez da Silva
Lista Circular Simplesmente Encadeada
1) Diga o que faz a função Descobrir, que recebe um ponteiro para o último nó de uma lista
circular simplesmente encadeada, que pode ser vazia. Em cada caso, dê um exemplo
com ilustrações gráficas.
Considere o tipo no, já definido em aula.
no *Descobrir(no *a, int valor) 
 {
no *aux;
aux = new no;
auxdado = valor;
if (a == NULL)
{
a = aux;
alink = a;
}
else
{
auxlink = alink;
alink = aux;
}
return a;
 } // fim da função
2) Faça um programa (aplicação) em C++ para ler a quantidade n de nós de uma lista circular
simplesmente encadeada de inteiros, sendo n ≥ 0. A lista deverá ser construída com n
nós, através de sucessivas inserções no final. Após sua criação, a lista deverá ser
impressa, se possível. Emita mensagem de erro em caso de lista vazia.
Nesta questão, implemente 2 funções/operações :
a) no *insereFim(no *p, int valor);
 p aponta para o primeiro nó da lista e valor é o elemento a ser inserido no final da lista.
b) void imprime(no *p); 
3) Considerando o programa do item 2) acima, em que o ponteiro externo aponta para o
primeiro nó da lista (nó mais à esquerda), implemente as seguintes operações (funções)
com a lista criada :
a) Remova o primeiro nó da lista, imprimindo-a ao final.
b) Remova o último nó da lista, imprimindo-a ao final.
c) Conte o número de nós da lista
d) Procure na lista um valor passado, realizando uma busca ou pesquisa seqüencial. A
função deverá retornar NULL ou o endereço do nó com o valor encontrado.
DISCIPLINA : Estrutura de Dados
8ª. Lista de Exercícios 
Elaborada por Profa Jane Tavares Alvarez da Silva
Lista Duplamente Encadeada
1) Considere uma lista duplamente encadeada apontada por um ponteiro x e ainda, um nó
fora da lista, apontado por um ponteiro p.
 Sabendo que x aponta para qualquer nó da lista, faça o que se pede :
a) Diga o que faz a função Eureka