Algoritmos e Estruturas de Dados. Lição n.º 3 Coleções: sacos, pilhas e filas

Transcrição

1 Algoritmos e Estruturas de Dados Lição n.º 3 Coleções: sacos, pilhas e filas

2 Coleções: sacos, pilhas e filas Especificação das coleções Classes iteráveis Sacos (em inglês bags) Implementação com arrays Pilhas (em inglês stacks) Implementação com listas Filas (em inglês queues) Implementação como exercício. Estudaremos hoje os sacos. As pilhas e as filhas ficam para uma das próximas lições. 2/8/17 Algoritmos e Estruturas de Dados 2

3 Coleções Coleções são... coleções! Às coleções podemos acrescentar objetos, removêlos e iterá-los. Podemos ainda perguntar-lhes se estão vazias e quantos objetos têm. Em Java teremos coleções genéricas, parametrizadas pelo tipo dos objetos que contêm. Por exemplo: public class Bag<T> //... As coleções apenas guardam os objetos. Por isso não há restrições sobre o tipo de objetos que podem conter. 2/8/17 Algoritmos e Estruturas de Dados 3

4 Classes iteráveis Queremos que as nossas coleções sejam iteráveis, isto é, que permitam aceder sequencialmente a cada um dos objetos da coleção. Programaremos isso fazendo cada coleção dispor de um método iterator que devolve um iterador. Paralelamente, declaramos a classe como implementando a interface Iterable<T>: public class Bag<T> implements Iterable<T> //... 2/8/17 Algoritmos e Estruturas de Dados 4

5 APIs public class Bag<T> implements Iterable<T> public Bag() public void add(t x) public boolean isempty() public int size() public Iterator<T> iterator() 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() public class Queue<T> implements Iterable<T> public Queue() public void enqueue(t x) public boolean isempty() public int size( public T dequeue() public Iterator<T> iterator() 2/8/17 Algoritmos e Estruturas de Dados 5

6 Capacidade? Como indicamos a capacidade das coleções? Não indicamos! Há apenas um construtor, sem argumentos. Logo, as coleções têm de ser capazes de aumentar a capacidade, se necessário (e, porventura, de diminuir a capacidade, se desejável). Para isso, implementamo-las à base de listas ligadas ou à base de arrays redimensionáveis. Um array redimensionável é um array cuja capacidade pode mudar durante a execução do programa. Aparentemente a expressão array redimensionável é um oximoro, pois habituámo-nos a que a capacidade de um array é fixada na sua criação e não muda mais. 2/8/17 Algoritmos e Estruturas de Dados 6

7 Sacos, implementação Vamos implementar a classe Bag<T> usando arrays redimensionáveis. Haverá um campo items, que é o array, e um campo size, que representa o número de elementos presentes no array: public class Bag<T> implements Iterable<T> private T[] items; private int size; //... Recorde que a capacidade do array está registada no membro length do array. 2/8/17 Algoritmos e Estruturas de Dados 7

8 Sacos, construtor Inicialmente, o array terá capacidade 1 e tamanho 0: public class Bag<T> implements Iterable<T> private T[] items; private int size; public Bag() items = (T[]) new Object[1]; size = 0; //... Note bem: criamos um array de objetos, e forçamos a conversão para array de T. 2/8/17 Algoritmos e Estruturas de Dados 8

9 Questão técnica: arrays genéricos Nós gostaríamos de ter programado a criação do array genérico items assim: items = new T[1]; No entanto, por razões técnicas, aceitáveis mas complicadas, o Java não permite a criação de arrays genéricos. Remedeia-se criando um array de objetos Object e forçando a conversão para o tipo de arrays pretendido. Em geral, forçar conversões de tipo é mau estilo. 2/8/17 Algoritmos e Estruturas de Dados 9

10 Supressão de avisos Como, forçar conversões é uma operação arriscada, o Java emite um warning: Evitamos o warning com uma public Bag() items = (T[]) new Object[1]; size = 0; Só usaremos o SuppressWarnings neste caso da construção de arrays genéricos! 2/8/17 Algoritmos e Estruturas de Dados 10

11 Redimensionamento Na verdade, não redimensionamos o array: criamos outro array com a capacidade pretendida e fazemos a com que a variável que apontava para o array original passe a apontar para o array novo: private void resize(int T[] temp = (T[]) new Object[capacity]; for (int i = 0; i < size; i++) Atenção: isto presume temp[i] = items[i]; que size <= capacity. items = temp; A memória do array original fica inacessível e será libertada automaticamente pelo garbage collector dentro em pouco. 2/8/17 Algoritmos e Estruturas de Dados 11

12 Método add Se, ao acrescentar um elemento ao saco, notarmos que já não há espaço no array, redimensionamo-lo para o dobro: public void add(t x) if (size == items.length) resize(2 * items.length); items[size++] = x; 2/8/17 Algoritmos e Estruturas de Dados 12

13 Métodos size e isempty Estes são muito simples: public int size() return size; public boolean isempty() return size == 0; 2/8/17 Algoritmos e Estruturas de Dados 13

14 O iterador Optamos por iterar pela ordem de entrada. Usamos uma classe interna: public class Bag<T> implements Iterable<T> //... private class BagIterator implements Iterator<T> private int i = 0; public boolean hasnext() return i < size; public T next() return items[i++]; public void remove() O método remove throw new UnsupportedOperationException(); não é suportado. 2/8/17 Algoritmos e Estruturas de Dados 14

15 O método iterator O método iterator apenas cria e retorna um objeto de tipo BagIterator: public Iterator<T> iterator() return new BagIterator(); Mais tarde, para, por exemplo, mostrar o conteúdo de saco de inteiros, b, faremos: for (int x: b) StdOut.println(x); 2/8/17 Algoritmos e Estruturas de Dados 15

16 Exemplo: problema dos estádios A federação tem a lista dos estádios, com nome, comprimento do relvado e largura do relvado. Pretende saber quais são os estádios com relvado de área máxima, de entre aqueles cujo relvado tem as dimensões regulamentares. Para a FIFA, o comprimento do relvado deve estar entre 90 e 120 metros e a largura entre 45 e 90 metros. Cada linha do ficheiro tem o nome (um cadeia de carateres sem espaços) o comprimento e a largura (ambos números inteiros). drag alg_arv light saintlouis alv_xxi Variante do problema usado em Laboratório de Programação 13/14. 2/8/17 Algoritmos e Estruturas de Dados 16

17 Classe Stadium Uma classe imutável, para representar estádios: public class Stadium private final String name; private final int length; private final int width; public static final int MIN_LENGTH = 90; public static final int MAX_LENGTH = 120; public static final int MIN_WIDTH = 45; public static final int MAX_WIDTH = 90; Stadium(String name, int length, int width) this.name = name; Note bem: por opção de desenho, os this.length = length; valores destes membros não podem this.width = width; mudar após a construção. //... 2/8/17 Algoritmos e Estruturas de Dados 17

18 Classe Stadium, continuação public class Stadium //... public int area() return length * width; public boolean islegal() return MIN_LENGTH <= length && length <= MAX_LENGTH && MIN_WIDTH <= width && width <= MAX_WIDTH; public static Stadium read() String s = StdIn.readString(); int u = StdIn.readInt(); int w = StdIn.readInt(); return new Stadium(s, u, w); Note bem: método estático. public String tostring() return name + " " + length + " " + width; Note bem: método redefinido. 2/8/17 Algoritmos e Estruturas de Dados 18

19 Classe do problema Usamos um saco de estádios. O saco é criado vazio (como todos os sacos) e depois é preenchido por leitura: public class StadiumProblem private Bag<Stadium> stadiums = new Bag<Stadium>(); public void read() while (!StdIn.isEmpty()) stadiums.add(stadium.read()); //... 2/8/17 Algoritmos e Estruturas de Dados 19

20 Estádios selecionados Os estádios selecionados também formam um saco: public class StadiumProblem //... public Bag<Stadium> selected() Bag<Stadium> result = new Bag<Stadium>(); int maxarea = -1; for (Stadium x: stadiums) if (x.islegal()) if (maxarea < x.area()) maxarea = x.area(); result = new Bag<Stadium>(); if (x.area() == maxarea) result.add(x); return result; De cada vez que surge uma nova área máxima, recomeça-se com um novo saco. //... 2/8/17 Algoritmos e Estruturas de Dados 20

21 Método solve Resolvemos o problema no método solve: public void solve() Bag<Stadium> solution = selected(); if (solution.isempty()) StdOut.println("(empty)"); else for (Stadium x : selected()) StdOut.println(x); A função de teste cria o objeto, lê e resolve: public static void testsolve() StadiumProblem sp = new StadiumProblem(); sp.read(); sp.solve(); A função main chama a função de teste: public static void main(string [] args) testsolve(); 2/8/17 Algoritmos e Estruturas de Dados 21

22 Diretoria work Tipicamente, guardaremos os nosso ficheiros de dados numa diretoria work, dentro do projeto, ao lado das diretorias bin e src (estas duas criadas pelo Eclipse). Nesse caso, podemos correr o programa a partir da diretoria work, redirigindo o input, assim, por exemplo: $ pwd /Users/pedro/Dropbox/AED_1516/ws2/Stadium $ ls bin src work $ cd work $ ls lz_in_01.txt lz_in_03.txt lz_in_05.txt lz_in_07.txt lz_in_02.txt lz_in_04.txt lz_in_06.txt lz_in_08.txt $ java -cp../../algs4.jar:../bin StadiumProblem < lz_in_01.txt saintlouis $ Também podemos redirigir o output, de maneira análoga, claro. 2/8/17 Algoritmos e Estruturas de Dados 22

23 Correndo na diretoria bin Alternativamente, podemos correr o programa na diretoria bin, como antes, tendo o cuidado de ir buscar o ficheiro à diretoria work: $ pwd /Users/pedro/Dropbox/AED_1516/ws2/Stadium $ ls bin src work $ cd bin $ java -cp../../algs4.jar:. StadiumProblem <../work/lz_in_07.txt (empty) $ java -cp../../algs4.jar:. StadiumProblem <../work/lz_in_08.txt arena stade_france millenium camp_nou bernabeu $ 2/8/17 Algoritmos e Estruturas de Dados 23

24 Custo do redimensionamento? Redimensionar o array que suporta o saco parece ser um grande trabalho suplementar. Será que é? Quando redimensionamos de N para 2N, quantos acessos se fazem aos arrays items e temp? O array temp é criado com 2N elementos e cada um deles tem de ser inicializado com null. Logo 2N acessos. A afectação temp[i] = items[i] faz-se N vezes. Logo, ao todo, mais 2N acessos. Portanto, ao redimensionar de 1 para 2, foram 4 acessos; de 2 para 4 foram 8 acessos;...; de N/2 para N foram 2N acessos. Portanto, se o array tiver N elementos e N for uma potência de 2, teremos usado N acessos só para o redimensionamento. Ora N = 4N 4. A estes há que somar os N acessos normais, para acrescentar no novo elemento ao saco. Logo, ao todo teremos tido 5N 4 acessos, para N elementos no array. Note que se tivéssemos alocado logo N elementos na criação, teria havido 2N acessos ao array, ao todo, mas em geral não sabemos o número de elementos exato, por isso, ao dimensionar por excesso logo de início pode acontecer trabalharmos mais do que ir redimensionando aos poucos. 2/8/17 Algoritmos e Estruturas de Dados 24