Pilhas e Filas

1. Pilhas e Filas

2. Sumário • Definição • Pilhas • Filas • Implementação Java • Implementação C++

3. Sumário • Implementação Java • Fundamentos • Pilhas • Implementação por arrays • Implementação por listas encadeadas • Filas • Implementação por arrays • Implementação por listas encadeadas • Implementação C++ • Fundamentos • Pilhas • Implementação por arrays • Implementação por listas encadeadas • Filas • Implementação por arrays • Implementação por listas encadeadas

4. Definição

5. Pilhas

6. Conceito de Pilha (1) • Pilha é o mais simples dos containers. • A operação de inclusão de elementos na pilha recebe o nome de empilhamento (push) e a operação de exclusão recebe o nome de desempilhamento (pop) • Um elemento empilhado vai ocupar a posição chamada de topo da pilha • Uma operação de desempilhamento provoca a exclusão do elemento no topo da pilha. Por esta razão as pilhas são chamadas de listas LIFO ( de “Last In First Out’). • Uma operação de desempilhamento em uma pilha vazia não tem sentido e configura uma situação denominada “underflow” • Pode-se verificar se uma pilha atingir a condição de contorno de pilha vazia através da função isEmpty que pode assumir os valores TRUE (pilha vazia) ou FALSE (pilha não vazia)

7. Conceito de Pilha (2) • Operações de empilhamento podem levar à situação na qual o numero de elementos na pilha seja igual ao número máximo de elementos comportados pelo container • Tentativas subseqüentes de empilhamento são impossíveis e configuram situação de transbordamento ou “overflow” • A situação de “underflow” é lógica e impossível de ser contornada. Freqüentemente não constitui erro de algoritmo e sim teste de uma condição • A situação de “overflow” é física e não lógica • Pode ser contornada aumentando o tamanho do container” hospedeiro • Contudo, durante o processamento configura um erro e deve interromper o processo

8. Conceito de Pilha (3) • Uma operação adicional sobre pilhas é a verificação do elemento no topo da pilha getTop. • Exemplos do dia a dia: • Pilhas de pratos • Pilhas de revistas

9. Conceito de Pilha (4)

10. Filas

11. Conceito de Fila • Fila é um container no qual todas as inclusões são efetuadas em uma extremidade chamada de retaguarda e todas as exclusões são efetuadas na outra extremidade denominada frente. • Como nas filas o primeiro elemento a entrar é o primeiro a sair, as filas são chamadas de listas FIFO (de First-In, First-Out). • Exemplos do dia a dia: • Filas de bancos • Filas de ônibus

12. Implementação por Arrays (1) • A formulação espontânea contém dois ponteiros frente e retaguarda ou head e tail • Inicia-se a fila com a condição de contorno head = 0 e tail = -1 • Caracteriza-se fila vazia quando tail < head • Fila cheia ocorre quando tail = array.length-1, onde array.length é o número máximo de elementos previstos no “array”. • Como as listas podem “correr na memória” este esquema não é eficiente • É mais vantajoso adotar filas circulares onde o primeiro elemento sucede o último e a implementação é feita por aritmética modular

13. Implementação por Arrays (2) • O ajustamento de ponteiros por ocasião de inclusões e exclusões se torna diferente • Inclusão: • tail (tail + 1) mod array.length ao invés de tail  tail + 1 • Exclusão: • head (head + 1 ) mod array.length ao invés de head  head + 1 • A fila vazia seria caracterizada por head = tail e a fila cheia também, o que não é satisfatório • Pode-se melhorar esta solução apontando head para a posição do “array” precedendo o primeiro elemento da fila. Esta será a opção adotada • A condição de file cheia se torna head = = (tail + 1) mod array.length

14. Implementação por Arrays (3) • A solução adotada pelo Framework de Bruno Preiss para as filas circulares é adotar a mesma condição de contorno tanto para fila cheia como para fila vazia head = tail • A diferença entre um caso e outro é dada pelo contador count sendo count == array.length para fila cheia e count == 0 para fila vazia • Esta solução permite a ocupação de todos os espaços do array enquanto a solução sem usar count (o conteúdo do container) exige que uma posição do array permaneça desocupada antes do início da fila

15. Exemplo de Fila

16. Filas circulares

17. Hierarquia de Classes para implementação no Framework de Bruno Preiss

18. Java C++

19. Implementação Java

20. Hierarquia de Classes

21. Fundamentos

22. Interface Comparable public interface Comparable { boolean isLT (Comparable object); boolean isLE (Comparable object); boolean isGT (Comparable object); boolean isGE (Comparable object); boolean isEQ (Comparable object); boolean isNE (Comparable object); int compare (Comparable object); }

23. Classe abstrata AbstractObject (1) // pgm05_02.java public abstract class AbstractObject implements Comparable { public final boolean isLT (Comparable object) { return compare (object) < 0; } public final boolean isLE (Comparable object) { return compare (object) <= 0; } public final boolean isGT (Comparable object) { return compare (object) > 0; } public final boolean isGE (Comparable object) { return compare (object) >= 0; } public final boolean isEQ (Comparable object) { return compare (object) == 0; } public final boolean isNE (Comparable object) { return compare (object) != 0; }

24. Classe abstrata AbstractObject (2) public final boolean equals (Object object) { if(object instanceof Comparable) return isEQ ((Comparable) object); else return false; } public final int compare (Comparable arg) { if(getClass () == arg.getClass()) return compareTo (arg); else return getClass().getName().compareTo( arg.getClass().getName() ); } protected abstract int compareTo (Comparable arg); }

25. Interface Container public interface Container extends Comparable { int getCount (); boolean isEmpty (); boolean isFull (); void purge (); void accept (Visitor visitor); Enumeration getEnumeration (); }

26. Classe Abstrata AbstractContainer public abstract class AbstractContainer extends AbstractObject implements Container { protected int count; public int getCount () { return count; } public boolean isEmpty () { return getCount () == 0; } public boolean isFull () { return false; } // ... }

27. Interface Stack // pgm06_01.java public interface Stack extends Container { Object getTop (); void push (Object object); Object pop (); }

28. Interface Queue // pgm06_13.java public interface Queue extends Container { Object getHead (); void enqueue (Object object); Object dequeue (); }

29. Pilhas

30. Pilhas Implementadas em Java Utilizando Arrays

31. Definição da Classe StackAsArray // pgm06_02.txt public class StackAsArray extends AbstractContainer implements Stack { protected Object[] array; // ... }

32. Métodos Construtor e purge da Classe StackAsArray // pgm06_03.java public class StackAsArray extends AbstractContainer implements Stack { protected Object[] array; public StackAsArray (int size) { array = new Object [size]; } public void purge () { while (count > 0) array [--count] = null; } // ... }

33. Métodos push, pop e getTop da Classe StackAsArray (1) // pgm06_04.java public class StackAsArray extends AbstractContainer implements Stack { protected Object[] array; public void push (Object object) { if(count == array.length) throw new ContainerFullException(); array [count++] = object; }

34. Métodos push, pop e getTop da Classe StackAsArray (2) // pgm06_04.java (Continuação) public Object pop () { if(count == 0) throw new ContainerEmptyException(); Object result = array [--count]; array[count] = null; return result; } public Object getTop () { if(count == 0) throw new ContainerEmptyException (); return array [count - 1]; } // ... }

35. Método accept da Classe StackAsArray // pgm06_05.java public class StackAsArray extends AbstractContainer implements Stack { protected Object[] array; public void accept (Visitor visitor) { for (int i = 0; i < count; ++i) { visitor.visit (array [i]); if(visitor.isDone ()) return; } } // ... }

36. Exemplo de uso de Enumeração (1) • Considere-se o código que se segue Stack stack = new StackAsArray (57); stack.push (new Integer (3)); stack.push (new Integer (1)); stack.push (new Integer (4)); Enumeration e = stack.getEnumeration (); while (e.hasMoreElements ()) { Object obj = e.nextElement (); System.out.println (obj); }

37. Exemplo de uso de Enumeração (2) • Este código cria uma instância da classe StackAsArray e a atribui à variável stack. • Diversos objetos do tipo Integer são empilhados. • Finalmente uma enumeração é usada para imprimir de maneira sistemática todos os objetos na pilha.

38. Classes interiores • Uma classe interior é uma classe definida dentro de outra. • A menos que seja declarada estática, cada instância de uma classe interior é suposta dentro de uma instância da classe exterior sendo as classes interiores não estáticas por default. • Instâncias de classes interiores podem invocar métodos de instâncias da classe exterior e ter acesso a seus membros.membros. • Pode haver mais de uma instância de classe interior para uma instância de classe exterior. • Uma classe anônima é uma classe sem nome. • Estas classes são criadas estendendo uma classe existente ou implementando uma interface bem no ponto do código aonde a classe está sendo instanciada.

39. Método getEnumeration da Classe StackAsArray // pgm06_06.java public class StackAsArray extends AbstractContainer implements Stack { protected Object[] array; public Enumeration getEnumeration() { return new Enumeration() { protected int position = 0; public boolean hasMoreElements() { return position < getCount (); } public Object nextElement() { if(position >= getCount ()) throw new NoSuchElementException(); return array [position++]; } }; } }

40. Pilhas Implementadas em Java Utilizando Listas Encadeadas

41. Definição da Classe StackAsLinkedList // pgm06_07.java public class StackAsLinkedList extends AbstractContainer implements Stack { protected LinkedList list; // ... }

42. Métodos Construtor e purge da Classe StackAsLinkedList // pgm06_08.java public class StackAsLinkedList extends AbstractContainer implements Stack { protected LinkedList list; public StackAsLinkedList () { list = new LinkedList (); } public void purge () { list.purge (); count = 0; } // ... }

43. Métodos push, pop e getTop da Classe StackAsLinkedList (1) // pgm06_09.java public class StackAsLinkedList extends AbstractContainer implements Stack { protected LinkedList list; public void push (Object object) { list.prepend (object); ++count; }

44. Métodos push, pop e getTop da Classe StackAsLinkedList (2) // pgm06_09.java (Continuação) public Object pop () { if(count == 0) throw new ContainerEmptyException (); Object result = list.getFirst (); list.extract (result); --count; return result; } public Object getTop () { if(count == 0) throw new ContainerEmptyException (); return list.getFirst (); } // ... }

45. Método accept da Classe StackAsLinkedList // pgm06_10.java public class StackAsLinkedList extends AbstractContainer implements Stack { protected LinkedList list; public void accept (Visitor visitor) { for(LinkedList.Element ptr = list.getHead (); ptr != null; ptr = ptr.getNext ()) { visitor.visit (ptr.getDatum ()); if(visitor.isDone ()) return; } } // ... }

46. Método getEnumeration da Classe StackAsLinkedList (1) // pgm06_11.java public class StackAsLinkedList extends AbstractContainer implements Stack { protected LinkedList list;

47. Método getEnumeration da Classe StackAsLinkedList (1) // pgm06_11.java (Continuação) public Enumeration getEnumeration () { return new Enumeration () { protected LinkedList.Element position =list.getHead(); public boolean hasMoreElements () { return position != null; } public Object nextElement () { if(position == null) throw new NoSuchElementException (); Object result = position.getDatum (); position = position.getNext (); return result; } }; } // ... }

48. Filas

49. Filas Implementadas em Java Utilizando Arrays

50. Definição da Classe QueueAsArray // pgm06_14.java public class QueueAsArray extends AbstractContainer implements Queue { protected Object[] array; protected int head; protected int tail; // ... }