Pilhas e filas

218 visualizações

Publicada em

Pilhas e Fila

Publicada em: Tecnologia
0 comentários
0 gostaram
Estatísticas
Notas
  • Seja o primeiro a comentar

  • Seja a primeira pessoa a gostar disto

Sem downloads
Visualizações
Visualizações totais
218
No SlideShare
0
A partir de incorporações
0
Número de incorporações
1
Ações
Compartilhamentos
0
Downloads
3
Comentários
0
Gostaram
0
Incorporações 0
Nenhuma incorporação

Nenhuma nota no slide

Pilhas e filas

  1. 1. FEUP/LEEC Algoritmos e Estruturas de Dados 2001/2002 Pilhas e Filas João Canas Ferreira http://www.fe.up.pt/~jcf FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 1 Conteúdo 1. Pilhas (a) Implementação baseada em listas (b) Implementação baseada em vectores 2. Filas (a) Implementação baseada em listas (b) Implementação baseada em vectores 3. Aplicações de pilhas (a) Cálculo de expressões RPN (b) Conversão de expressões inxas para RPN 4. Aplicação de las (a) Percurso mais curto num labirinto FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 2 1
  2. 2. Pilhas Pilha Estrutura de dados em que a inserção e a remoção de elemen-tos 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 ecazes. O conceito de iterador não se aplica a esta estrutura de dados. LIFO = Last-in First-out FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 3 Operações com pilhas 1 2 1 2 3 4 5 1 3 2 1 4 3 2 1 5 4 3 2 1 5 4 3 2 1 5 4 3 2 1 5 4 3 4 3 2 1 3 2 1 2 2 1 2 1 5 4 3 2 1 FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 4 2
  3. 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,2001/2002, v0.1 Pilhas e Filas # 5 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,2001/2002, v0.1 Pilhas e Filas # 6 3
  4. 4. push() e top() template class T void LStackT::push(const T x) { topOfStack = new ListNode(x, topOfStack); } template class T const T LStackT::top() const { if (isEmpty()) throw Underflow(); return topOfStack-element; } FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 7 pop() e topAndPop() template class T void LStackT::pop() { if (isEmpty()) throw Underflow(); ListNode *oldTop = topOfStack; topOfStack = topOfStack-next; delete oldTop; } template class T T LStackT::topAndPop() { T topItem = top(); pop(); return topItem; } FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 8 4
  5. 5. Pilhas–Implementação baseada em vectores template class T class VStack { public: explicit VStack(int capacity = 100); bool isEmpty() const; bool isFull() const; const T top() const; void makeEmpty(); void pop(); void push(const T x); T topAndPop(); //... FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 9 VStack – Secção privada template class T class VStack { // ... private: vectorT theArray; int topOfStack; }; Atenção: Não deixar o vector aumentar de tamanho. topOfStack = 3 VAZIO topOfStack = -1 FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 10 5
  6. 6. Classe VStack – Implementação template class T bool VStackT::isFull() const { return topOfStack == theArray.size() - 1; } template class T void VStackT::makeEmpty() { topOfStack = -1; } template class T void VStackT::push(const T x) { if (isFull()) throw Overflow(); theArray[++topOfStack] = x; } FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 11 Classe VStack – pop() e top() template class T const T VStackT::top() const { if (isEmpty()) throw Underflow(); return theArray[topOfStack]; } template class T void VStackT::pop() { if (isEmpty()) throw Underflow(); topOfStack--; } template class T T VStackT::topAndPop() { if (isEmpty()) throw Underflow(); return theArray[topOfStack--]; } FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 12 6
  7. 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 la. Uma la 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 ecazes. O conceito de iterador não se aplica a esta estrutura de dados. FIFO = First-in First-out FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 13 Funcionamento de las 1 2 3 4 5 1 1 2 1 2 3 1 2 3 4 1 2 3 4 5 2 3 4 5 3 4 5 4 5 1 2 3 4 5 5 1 2 3 4 5 FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 14 7
  8. 8. Filas – Implementação com listas LQueuechar back front a b c d FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 15 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,2001/2002, v0.1 Pilhas e Filas # 16 8
  9. 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,2001/2002, v0.1 Pilhas e Filas # 17 Classe LQueue – enqueue() e dequeue template class T void LQueueT::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 LQueueT::dequeue() { if (isEmpty()) throw Underflow(); ListNode *oldFront = front; front = front-next; delete oldFront; if (!front) back = 0; } FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 18 9
  10. 10. Filas – Implementação com vectores Importante: Evitar deslocar os elementos do vector. a b c d front back b c d front back b c d e front back tirar ’a’ colocar ’e’ tirar ’b’ c d e front back c d e back front tirar ’c’ d e back front colocar ’f’ f f FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 19 Classe CQueue – secção privada template class T class CQueue { public: explicit CQueue(int capacity = 100); // ... private: vectorT theArray; int currentSize; int front, back; void increment(int x); }; O campo currentSize não é estritamente necessário, mas facilita bas-tante a gestão da estrutura. Nota: Não se permite a extensão do vector. FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 20 10
  11. 11. Classe CQueue – enqueue() e dequeue() template class Tvoid CQueueT::enqueue(const T x) { if (isFull()) throw Overflow(); increment(back); theArray[back] = x; currentSize++; } template class T void CQueueT::increment(int x) { if (++x == theArray.size()) x = 0; } template class T T CQueueT::dequeue() { if (isEmpty()) throw Underflow(); currentSize--; int oldFront = front; increment(front); return theArray[oldFront]; } FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 21 Notação RPN Notação RPN: Expressões aritméticas em que os operadores surgem a seguir aos operandos (notação pós-xa). RPN=Reverse Polish Notation Notação inxa: Os operadores binários surgem entre os operandos. Notação inxa: 2 * ( 4 + 5 ) / 3 Notação RPN: 2 4 5 + * 3 / Vantagens de RPN: Não requer parênteses nem regras de precedência. FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 22 11
  12. 12. Avaliação de expressões RPN–Exemplo Uma expressão RPN é facilmente avaliada com a ajuda de uma pilha. 2 4 5 + * 3 / 2 4 5 + * 3 / 2 4 5 + * 3 / 2 4 5 + * 3 / 2 4 5 + * 3 / 2 4 5 + * 3 / 2 4 5 + * 3 / 2 4 2 5 4 2 9 2 18 3 18 6 FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 23 Avaliação de expressões RPN–Algoritmo 1. 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. 2. Retirar o (único) elemento da pilha: é o resultado. (Ver tb. secção 3.3.3 de [DSAA].) FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 24 12
  13. 13. Especicação de um programa para avaliar expressões RPN 1. Ler expressões de cin; 2. Os elementos da expressão são separados por espaços e termina-das com =; 3. Escrever os resultados em cout; 4. Ignorar linhas vazias; 5. Terminar com m-de-cheiro (^D em Unix, ^Z em Windows) FEUP/LEEC,AED,2001/2002, v0.1 Pilhas e Filas # 25 Conversão entre notação inxa e RPN A conversão entre notação inxa 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,2001/2002, v0.1 Pilhas e Filas # 26 13
  14. 14. Exemplo de conversão inxo

×