Você está na página 1de 7

Lista de Exercícios - Estruturas de Dados Filas e Pilhas

1. Implemente uma fila, utilizando encadeamento (indireção) nos nós. Segue esboço da
implementação:

typedef int Dado;

class noh {
friend class fila;
private:
Dado dado;
noh* proximo;
public:
noh(Dado d = 0);
};

class fila {
private:
noh* inicio;
noh* fim;
int tamanho;
public:
fila();
void enfileira(Dado valor);
Dado desenfileira();
Dado espia();
};
2. Implemente uma pilha, utilizando encadeamento (indireção) nos nós. Segue esboço da
implementação:

typedef int Dado;

class noh {
friend class pilha;
private:
Dado dado;
noh* proximo;
public:
noh(Dado d = 0);
};

class pilha {
private:
noh* topo;
int tamanho;
public:
pilha();
void empilha(Dado valor);
Dado desempilha();
Dado espia();
}
3. Escreva um algoritmo para determinar se uma string de caracteres de entrada é da forma
xCy, onde x é uma string consistindo das letras A e B e y é o inverso de x (use uma pilha para
resolver o problema).

4, Em Linguagens Formais e Autômatos um reconhecedor é um meio formal de verificar se


uma dada sentença pertence ou não a uma determinada linguagem. Uma linguagem pode ser
definida com um subconjunto de S*, a partir de um alfabeto S, onde S é um conjunto finito,
não vazio, de símbolos.
Considere o alfabeto S = {A,B,C} e a linguagem L = {AiBC2iBAi | i > 0}, ou seja, as
sequências ABCCBA, AABCCCCBAA, AAABCCCCCCBAA são todas pertencentes ao
conjunto de sentenças válidas de L. Faça um programa que, dada uma sequência w de
caracteres A, B e C, verifique se w faz parte ou não do conjunto de sentenças de L. Utilize
uma pilha para fazer essa verificação.

5. Considere o alfabeto S = {A,B,C} e a linguagem L = {AnCmBn | n > 0, m ≥ 0}, ou seja, as


sequências AAACBBB, ACCCB, AAABBB são todas pertencentes ao conjunto de
sentenças válidas de L. Essa linguagem pode ser utilizada para representar uma série de
estruturas em computação, como parênteses aninhados. Faça um programa que, dada uma
sequência w de caracteres A, B e C, verifique se w faz parte ou não do conjunto de sentenças
de L. Utilize uma pilha para fazer essa verificação.

6. Mostre como uma pilha pode ser implementada utilizando duas filas. Analise o tempo das
operações de empilhar (PUSH) e desempilhar (POP).
7. Um deque é um conjunto de itens a partir do qual podem ser eliminados e inseridos itens
em ambas as extremidades. Chame as duas extremidades de um deque esq e dir. Escreva
quatro funções em C++, RemDir, RemEsq, InsDir, InsEsq, para remover e inserir elementos
nas extremidades esquerda e direita de um deque. Certifique-se de que as funções funcionem
corretamente para o deque vazio e detectem o estouro e o underflow (tentativa de remoção
quando a fila está vazia). Segue esboço da implementação:

// deque
class deque {
private:
noh* esquerda;
noh* direita;
int tamanho;
public:
deque();
~deque();
void insereNaEsquerda(Dado dado);
void insereNaDireita(Dado dado);
Dado retiraEsquerda();
Dado retiraDireita();
Dado espiaEsquerda();
Dado espiaDireita();
void imprime();
inline bool vazia();
};
8. Implemente uma fila circular, utilizando armazenamento dos dados em arranjos. Segue
esboço da implementação:

typedef int Dado; // para facilitar a troca de int para outro tipo

// fila implementada em arranjo (circular)


class fila {
private:
int capacidade;
Dado *dados;
int tamanho;
int posInicio;
int posFim;
public:
filav(int cap = 100);
~filav();
void enfileira(Dado valor);
Dado desenfileira();
Dado espia(); // acessa elemento do topo, mas não retira
void depura(); // imprime os dados do vetor da fila
void info(); // imprime informações da fila (tamanho,
// posInicio, posFim, etc.
};
9. Implemente uma pilha, utilizando armazenamento dos dados em arranjos. Segue esboço da
implementação:

typedef int Dado; // para facilitar a troca de int para outro tipo

// pilha implementada em arranjo


class pilhav {
private:
int capacidade;
Dado *dados;
int tamanho;
int posTopo;
public:
pilhav(int cap = 100);
~pilhav();
void empilha(Dado valor);
Dado desempilha();
Dado espia(); // acessa elemento do topo, mas não retira
void depura(); // imprime os dados do vetor da pilha
void info(); // imprime informações da pilha (tamanho,
// posInicio, posFim, etc.
};

8. Considere uma calculadora que utilize notação posfixa, ou seja, a operação


(5 * 3 ) + 5
deve ser digitada como sendo
53*5+
Considere ainda que são permitidas apenas as quatro operações fundamentais e que os
símbolos que representam as operações são + (soma), - (subtração), * (multiplicaçã) e /
(divisão). Faça um programa que simule o funcionamento de tal calculadora. Uma pilha deve
ser utilizada para leitura dos números e operadores.
10. Escreva um programa que implemente uma fila circular utilizando uma lista dinâmica. O
programa deve ser capaz de inserir, remover e informar o tamanho da fila em um dado
momento.

11. Faça um programa que inverta o conteúdo de uma fila usando apenas as funções de
acesso.

12. Faça uma função que receba três filas, duas já preenchidas em ordem crescente e
preencha a última com os valores das duas primeiras em ordem crescente.

13. Faça uma função que receba duas pilha e verifique se elas são iguais, retornando
verdadeiro ou falso.

14. Implemente uma fila de prioridade usando por base uma fila encadeada. Nesse caso, cada
nó da fila terá, além dos dados, um atributo que indica a prioridade do nó. Considere que
quanto maior esse valor, maior será sua prioridade.