Algoritmos e Estruturas de Dados. Lição n.º 4 Pilhas

Transcrição

1 Algoritmos e Estruturas de Dados Lição n.º 4 Pilhas

2 Pilhas Implementação com arrays redimensionáveis. Implementação com listas ligadas. Aplicação: avaliação de expressões aritméticas usando o algoritmo da pilha dupla, de Dijkstra Algoritmos e Estruturas de Dados 2

3 Pilhas As pilhas chamam-se pilhas porque funcionam como pilhas...; pilhas de livros, de pratos, de papéis, não pilhas no sentido de baterias elétricas! A ideia é que o elemento que sai é o último que entrou. Dizemos que as pilhas são coleções LIFO: last in first out Algoritmos e Estruturas de Dados 3

4 API da pilha Já sabemos: public class Stack<T> implements Iterable<T> public Stack() public void push(t x) public boolean isempty() public int size() public T pop() public Iterator<T> iterator() Comparando com Bag<T>, temos push em vez de add, temos pop e o iterador emitirá os elementos por ordem inversa de entrada na pilha (os que entraram mais recentemente surgem primeiro) Algoritmos e Estruturas de Dados 4

5 Implementação com arrays redimensionáveis É análoga à da classe Bag<T>: public class Stack<T> implements Iterable<T> private T[] items; private int size; public Stack() private void resize(int capacity) public void push(t x) if (size == items.length) resize(2 * items.length); items[size++] = x; Se o array cresce quando está cheio, será que deve encolher quando fica relativamente vazio? Algoritmos e Estruturas de Dados 5

6 Encolhendo no pop A estratégia será encolher para metade quando o tamanho estiver a 25% da capacidade: public class Stack<T> implements Iterable<T> public T pop() T result = items[--size]; items[size] = null; if (size > 0 && size == items.length / 4) resize(items.length / 2); return result; Anula-se o apontador para que não permaneça no array uma referência para o elemento removido, o que atrasaria a garbage collection. Se não anulássemos, teríamos vadiagem (em inglês, loitering): referências no array para valores inúteis. Note bem: não seria sensato encolher para metade quando o array estivesse meio cheio, pois nesse caso ele ficava cheio logo após ter encolhido, e se houvesse um push a seguir, teria de crescer de novo Algoritmos e Estruturas de Dados 6

7 Iterador reverso Nas pilhas, queremos iterar os elementos de maneira a ver primeiro os que entraram na pilha mais recentemente: private class StackIterator implements Iterator<T> private int i = size; public boolean hasnext() return i > 0; public T next() return items[--i]; public Iterator<T> iterator() return new StackIterator(); Algoritmos e Estruturas de Dados 7

8 Função de teste Eis uma função de teste, que empilha os números lidos e desempilha com -. No fim mostra o tamanho, se é vazia e os elementos, por iteração: private static void teststackinteger() Stack<Integer> s = new Stack<Integer>(); while (!StdIn.isEmpty()) String t = StdIn.readString(); if (!"-".equals(t)) s.push(integer.parseint(t)); else if (!s.isempty()) int x = s.pop(); StdOut.println(x); StdOut.println("size of stack = " + s.size()); StdOut.println("is stack empty? " + s.isempty()); StdOut.print("items:"); for (int x : s) StdOut.print(" " + x); StdOut.println(); Ctrl-D aqui! Algoritmos e Estruturas de Dados 8

9 Implementação com listas ligadas A lista ligada é programada em termos da classe interna Node, a qual detém um campo para o valor e uma referência para o próximo nó: public class StackLists<T> implements Iterable<T> private class Node private T value; private Node next; Ver transparentes de POO, página 13-8 e seguintes. Node(T x, Node z) value = x; next = z; Algoritmos e Estruturas de Dados 9

10 O primeiro nó Na pilha, um dos membros é o primeiro nó da lista; o outro é o tamanho: public class StackLists<T> implements Iterable<T> private Node first; private int size; Omitimos o construtor por defeito, uma vez que os valores iniciais automáticos (null para first e 0 para size) são os que nos interessam Algoritmos e Estruturas de Dados 10

11 Empilhar, desempilhar Para empilhar, criamos um novo nó, que passa a ser o primeiro, ligando-o ao que estava em primeiro antes: public void push(t x) first = new Node(x, first); size++; Para desempilhar, devolvemos o valor do primeiro nó, e avançamos para o seguinte a referência: public T pop() T result = first.value; first = first.next; size--; return result; Algoritmos e Estruturas de Dados 11

12 isempty, size Os métodos isempty e size são muito simples: public boolean isempty() return first == null; public int size() return size; Poderíamos ter omitido o campo size e ter programado a função size contando iterativamente os nós, mas, por decisão de desenho preferimos que função size seja calculada em tempo constante Algoritmos e Estruturas de Dados 12

13 Iterador de listas O cursor é uma referência para o nó corrente: private class StackIterator implements Iterator<T> private Node cursor = first; public boolean hasnext() return cursor!= null; public T next() T result = cursor.value; cursor = cursor.next; return result; Repare que o nó first contém o valor que mais recentemente foi empilhado, de entre todos os que estão na pilha. Tal como na outra implementação, os valores são enumerados pela ordem inversa de entrada na pilha. public Iterator<T> iterator() return new StackIterator(); Algoritmos e Estruturas de Dados 13

14 Avaliação de expressões aritméticas Como exemplo de aplicação das listas, estudemos a avaliação de expressões aritméticas usando o algoritmo da pilha dupla de Dijkstra. As expressões aritmética que nos interessam são completamente parentetizadas, para evitar as questões da precedência dos operadores. Admitiremos os quatro operadores básicos ( +, -, * e / ) e a raiz quadrada ( sqrt ). Os operandos são números decimais, com ou sem parte decimal. Exemplos: ((7*2)+5) ((sqrt(9+16))/3) (((6*3)+(7-3))/2) Algoritmos e Estruturas de Dados 14

15 Pilha dupla de Dijkstra Usamos duas pilhas: uma pilha de cadeias, para os operadores, e uma pilha de números, para os operandos e para os resultados parciais. Varremos a expressão da esquerda para a direita, recolhendo os operadores, os operandos e os parênteses: Cada operador é empilhado na pilha dos operandos. Cada operando é empilhado na pilha dos números. Os parênteses a abrir são ignorados. Ao encontrar um parêntesis a fechar, desempilha-se um operador, depois desempilham-se os operandos (em número apropriado ao operador), aplica-se a operação a esses operando e empilha-se o resultado, na pilha dos números. Depois de o último parêntesis ter sido processado, a pilha dos números terá um único elemento, cujo valor é o valor da expressão Algoritmos e Estruturas de Dados 15

16 Classe DijkstraTwoStack Primeiro as operações de suporte: public final class DijkstraTwoStack private DijkstraTwoStack() private static String[] knownoperators = "+", "-", "*", "/", "sqrt"; private static String[] binaryoperators = "+", "-", "*", "/"; private static String[] unaryoperators = "sqrt"; private static <T> boolean has(t[] a, T x) for (T i : a) if (x.equals(i)) Busca linear. return true; return false; private static boolean isoperator(string s) return has(knownoperators, s); private static boolean isbinaryoperator(string s) return has(binaryoperators, s); private static boolean isnumeric(string s) return Character.isDigit(s.charAt(0)); Algoritmos e Estruturas de Dados 16

17 Avaliação da expressão A seguinte função meramente exprime as regras do algoritmo: private static double evaluationsimple(string[] ss) Stack<String> operators = new Stack<String>(); Stack<Double> values = new Stack<Double>(); for (String s : ss) if ("(".equals(s)) // nothing to do else if (isoperator(s)) operators.push(s); A expressão é representada pelo array dos tóquenes: operandos, operadores e parêntesis. else if (isnumeric(s)) values.push(double.parsedouble(s)); else if (")".equals(s)) String op = operators.pop(); double z; values.push(z); else throw new UnsupportedOperationException(); return values.pop(); Algoritmos e Estruturas de Dados 17

18 Aplicação dos operadores String op = operators.pop(); // StdOut.println(op); double y = values.pop(); // StdOut.println(y); double x = isbinaryoperator(op)? values.pop() : 0.0; // StdOut.println(x); double z; if ("+".equals(op)) z = x + y; else if ("-".equals(op)) z = x - y; else if ("-".equals(op)) z = x + y; else if ("*".equals(op)) z = x * y; else if ("/".equals(op)) z = x / y; else if ("sqrt".equals(op)) z = Math.sqrt(y); Comprido e desinteressante. else throw new UnsupportedOperationException(); // will not happen; values.push(z); Algoritmos e Estruturas de Dados 18

19 Função de teste Para abreviar, determinamos que os tóquenes na expressão vêm separados por espaços. Assim, podemos obter o array de tóquenes diretamente, usando a função split: public static void testevaluationsimple() while (StdIn.hasNextLine()) String line = StdIn.readLine(); double z = evaluationsimple(line.split(" ")); StdOut.println(z); split public String[] split(string regex) Splits this string around matches of the given regular expression. O método split, da classe String, devolve um array de String Algoritmos e Estruturas de Dados 19

20 Experiência Na linha de comando: pedros- imac- 4:bin pedro$ java - cp../stdlib.jar:. DijkstraTwoStack ( ) 9.0 ( sqrt 2 ) ( ( ) / 3 ) 5.0 ( ( ) / ( ) ) 0.25 ( sqrt ( 1 + ( sqrt ( 1 + ( sqrt ( 1 + ( sqrt ( ) ) ) ) ) ) ) ) Próximas tarefas: Evitar ter de separar os tóquenes por espaços. Evitar ter de distinguir os operadores com if-else em cascata Algoritmos e Estruturas de Dados 20