Pilhas e Filas. Conteúdo. FEUP/LEEC Algoritmos e Estruturas de Dados 2001/2002. João Canas Ferreira

Transcrição

1 FEUP/LEEC Algoritmos e Estruturas de Dados 00/00 Pilhas e Filas João Canas Ferreira FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # Conteúdo. Pilhas (a) Implementação baseada em listas (b) Implementação baseada em vectores. Filas (a) Implementação baseada em listas (b) Implementação baseada em vectores. Aplicações de pilhas (a) Cálculo de expressões RPN (b) Conversão de expressões infixas para RPN. Aplicação de filas (a) Percurso mais curto num labirinto FEUP/LEEC,AED,00/00, v0. Pilhas e Filas #

2 Pilhas Pilha Estrutura de dados em que a inserção e a remoção de elementos de uma sequência se faz pela mesma extremidade, geralmente designada por topo da pilha. Uma pilha pode ser considerada como uma restrição de lista. Visto que se trata de uma estrutura de dados mais simples que a lista, é possível obter implementações mais eficazes. O conceito de iterador não se aplica a esta estrutura de dados. LIFO = Last-in First-out FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # Operações com pilhas FEUP/LEEC,AED,00/00, v0. Pilhas e Filas #

3 Pilha Implementação baseada em listas template <class T> class LStack public: LStack(); LStack(const LStack &stk); ~LStack(); bool isempty() const; bool isfull() const; const T & top() const; void makeempty(); void pop(); void push(const T &x); T topandpop(); const LStack & operator=(const LStack &stk); ///... FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # Classe LStack Secção privada template <class T> class LStack //... private: class ListNode // classe privada public: T element; ListNode *next; ; ListNode(const T & elem, ListNode *n = 0) : element(elem), next(n) ; ; ListNode *topofstack; FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # 6

4 push() e top() template <class T> void LStack<T>::push(const T &x) topofstack = new ListNode(x, topofstack); template <class T> const T & LStack<T>::top() const if (isempty()) throw Underflow(); return topofstack->element; FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # 7 pop() e topandpop() template <class T> void LStack<T>::pop() if (isempty()) throw Underflow(); ListNode *oldtop = topofstack; topofstack = topofstack->next; delete oldtop; template <class T> T LStack<T>::topAndPop() T topitem = top(); pop(); return topitem; FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # 8

5 Pilhas Implementação baseada em vectores template <class T> class VStack public: explicit VStack(int capacity = 00); bool isempty() const; bool isfull() const; const T & top() const; void makeempty(); void pop(); void push(const T &x); T topandpop(); //... FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # 9 VStack Secção privada template <class T> class VStack //... private: vector<t> thearray; int topofstack; ; Atenção: Não deixar o vector aumentar de tamanho. topofstack = VAZIO topofstack = - FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # 0

6 Classe VStack Implementação template <class T> bool VStack<T>::isFull() const return topofstack == thearray.size() - ; template <class T> void VStack<T>::makeEmpty() topofstack = -; template <class T> void VStack<T>::push(const T &x) if (isfull()) throw Overflow(); thearray[++topofstack] = x; FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # Classe VStack pop() e top() template <class T> const T & VStack<T>::top() const if (isempty()) throw Underflow(); return thearray[topofstack]; template <class T> void VStack<T>::pop() if (isempty()) throw Underflow(); topofstack--; template <class T> T VStack<T>::topAndPop() if (isempty()) throw Underflow(); return thearray[topofstack--]; FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # 6

7 Filas Fila Estrutura de dados em que a inserção e a remoção de elementos de uma sequência se faz por extremidades opostas, geralmente designadas por cabeça e cauda da fila. Uma fila pode ser considerada como uma restrição de lista. Visto que se trata de uma estrutura de dados mais simples que a lista, é possível obter implementações mais eficazes. O conceito de iterador não se aplica a esta estrutura de dados. FIFO = First-in First-out FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # Funcionamento de filas FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # 7

8 Filas Implementação com listas LQueue<char> back front a b c d FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # Classe LQueue secção pública template <class T> class LQueue public: LQueue(); LQueue(const LQueue &stk); ~LQueue(); bool isempty() const; bool isfull() const; const T & getfront() const; void makeempty(); void dequeue(); void enqueue(const T &x); const LQueue & operator=(const LQueue &stk); //... ; FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # 6 8

9 Classe LQueue secção privada template <class T> class LQueue //... private: class ListNode public: T element; ListNode *next; ListNode(const T & elem, ListNode *n = 0) : element(elem), next(n) ; ; ListNode *front, *back; ; FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # 7 Classe LQueue enqueue() e dequeue template <class T> void LQueue<T>::enqueue(const T &x) ListNode *oldback = back; back = new ListNode(x, 0); if (oldback) oldback->next = back; if (!front) front = back; template <class T> void LQueue<T>::dequeue() if (isempty()) throw Underflow(); ListNode *oldfront = front; front = front->next; delete oldfront; if (!front) back = 0; FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # 8 9

10 Filas Implementação com vectores Importante: Evitar deslocar os elementos do vector. tirar a a b c d b c d front back colocar e front back b c d e tirar b c d e front back front back colocar f f c d e tirar c f d e back front back front FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # 9 Classe CQueue secção privada template <class T> class CQueue public: explicit CQueue(int capacity = 00); //... private: vector<t> thearray; int currentsize; int front, back; void increment(int &x); ; O campo currentsize não é estritamente necessário, mas facilita bastante a gestão da estrutura. Nota: Não se permite a extensão do vector. FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # 0 0

11 Classe CQueue enqueue() e dequeue() template <class T>void CQueue<T>::enqueue(const T &x) if (isfull()) throw Overflow(); increment(back); thearray[back] = x; currentsize++; template <class T> void CQueue<T>::increment(int &x) if (++x == thearray.size()) x = 0; template <class T> T CQueue<T>::dequeue() if (isempty()) throw Underflow(); currentsize--; int oldfront = front; increment(front); return thearray[oldfront]; FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # Notação RPN Notação RPN: Expressões aritméticas em que os operadores surgem a seguir aos operandos (notação pós-fixa). RPN=Reverse Polish Notation Notação infixa: Os operadores binários surgem entre os operandos. Notação infixa: Notação RPN: * ( + ) / + * / Vantagens de RPN: Não requer parênteses nem regras de precedência. FEUP/LEEC,AED,00/00, v0. Pilhas e Filas #

12 Avaliação de expressões RPN Exemplo Uma expressão RPN é facilmente avaliada com a ajuda de uma pilha. + * / + * / + * / + * / + * / + * / + * / FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # Avaliação de expressões RPN Algoritmo. Processar sequencialmente os elementos da expressão. Para cada elemento: (a) Se o elemento for um número, colocá-lo na pilha; (b) Se for um operador i. Retirar os dois elementos do topo da pilha; ii. Processar os elementos de acordo com o operador; iii. Colocar o resultado na pilha.. Retirar o (único) elemento da pilha: é o resultado. (Ver tb. secção.. de [DSAA].) FEUP/LEEC,AED,00/00, v0. Pilhas e Filas #

13 Especificação de um programa para avaliar expressões RPN. Ler expressões de cin;. Os elementos da expressão são separados por espaços e terminadas com =;. Escrever os resultados em cout;. Ignorar linhas vazias;. Terminar com fim-de-ficheiro (^D em Unix, ^Z em Windows) FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # Conversão entre notação infixa e RPN A conversão entre notação infixa e RPN também pode ser feita com o recurso a uma pilha. A pilha é usada para guardar os operadores pendentes ; quando surge um operador todos os operadores de maior ou igual precedência são retirados da pilha. Quando surge um ) esvazia-se a pilha até encontrar o primeiro (. Prioridades: ( / * + - FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # 6

14 Exemplo de conversão infixo RPN * ( + ) / ; * ( + ) / ; * ( + ) / ; * ( + ) / ; * ( + ) / ; * ( + ) / ; * ( + ) / ; * ( + ) / ; * ( + ) / ; * ( + ) / ; + + ( ( ( ( * * * * * * / / Saída: + * / = FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # 7 Especificação do programa de conversão. Ler expressões de cin;. Os elementos da expressão são separados por espaços e terminadas com ponto-e-vírgula;. Escrever os resultados em cout, terminados com =;. Ignorar linhas vazias;. Terminar com fim-de-ficheiro (^D em Unix, ^Z em Windows) Os dois programas anteriores podem ser combinados em Unix: # ir postfix * ( + ) ; ^D FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # 8

15 Percurso mais curto Algoritmo de Lee Como encontrar o percurso mais curto entre dois pontos de um labirinto? a a b b FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # 9 Algoritmo de Lee. Numerar todos os vizinhos do ponto inicial com.. Colocar os vizinhos numa fila.. Enquanto a fila não estiver vazia e não se tiver atingido o ponto de destino: (a) Retirar um ponto da fila; (b) Numerar os seus vizinhos livres com o número do ponto acrescido de ; (c) Colocar os novos pontos (vizinhos) na fila. Se a fila estiver vazia e não se tiver atingido o ponto de destino, não existe percurso. Caso contrário, escrever o percurso em cout. FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # 0

16 Especificação do labirinto (,) (0,) FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # Especificação do programa. Ler um ficheiro com: dimensão do labirinto; zonas livres e ocupadas; pontos inicial e final.. Fazer verificações de consistência;. Aplicar algoritmo de Lee;. Imprimir percurso em cout. FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # 6

17 Representação interna do labirinto FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # Pontos e cálculo da vizinhança class Ponto public: int linha, coluna; Ponto(int li = 0, int col = 0) : linha(li), coluna(col) ; bool operator==(const Ponto &pt) const return (linha == pt.linha) && (coluna == pt.coluna); ; // Cálculo de vizinhança const int n_viz = ; int delta_linha[n_viz] = 0,, 0, - ; int delta_coluna[n_viz] =, 0, -, 0 ; //... for (int i = 0; i < n_viz; i++) vizinho.linha = corrente.linha + delta_linha[i]; vizinho.coluna = corrente.coluna + delta_coluna[i]; //... FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # 7

18 Determinação do percurso Ponto *percurso = new Ponto [comprimento_percurso]; // refazer o percurso do ponto final para o inicial corrente = fim; for (int j = comprimento_percurso -; j >= 0; j--) percurso[j] = corrente; // encontrar predecessor for (int i = 0; i < n_viz; i++) vizinho.coluna = corrente.coluna + delta_coluna[i]; vizinho.linha = corrente.linha + delta_linha[i]; if (grelha[vizinho.linha][vizinho.coluna] == j + ) break; corrente = vizinho; FEUP/LEEC,AED,00/00, v0. Pilhas e Filas # 8