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 a próxima lição 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 não inspecionam os objetos que contêm, apenas os guardam, e por isso não há restrições sobre o tipo de objetos que podem conter Algoritmos e Estruturas de Dados 3

4 Classes iteráveis Queremos que as nossas coleções sejam iteráveis, isto é, que permitam processar sequencialmente 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> // 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() 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 Algoritmos e Estruturas de Dados 6

7 Sacos, implementação Vamos implementar a classe Bag 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 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 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 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! 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 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; 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; 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 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); 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/ 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 s, int u, int w) name = s; length = u; width = w; //... Note bem: por opção de desenho, os valores destes membros não podem mudar após a construção 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 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()); // 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. // Algoritmos e Estruturas de Dados 20

21 Método solve Resolvemos o problema no método solve: public void solve() read(); Bag<Stadium> solution = selected(); if (solution.isempty()) StdOut.println("(empty)"); else for (Stadium x : selected()) StdOut.println(x); A função main cria um problema e invoca o método solve: public static void main(string [] args) new StadiumProblem().solve(); 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 (criadas pelo Eclipse). Nesse caso, podemos correr o programa a partir da diretoria work, redirigindo o input, assim, por exemplo: Também podemos redirigir o output, de maneira análoga, claro Algoritmos e Estruturas de Dados 22

23 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 elemento 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 e portanto temos de dimensionar por excesso Algoritmos e Estruturas de Dados 23

24 Exercício Dispomos de um ficheiro com as cotações na bolsa de Lisboa. Em cada linha vem o nome do papel, a cotação no início da sessão, o mínimo da sessão, o máximo da sessão, a cotação corrente e o número de transações desse papel. Queremos saber quais os papéis cuja variação (corrente menos inicial sobre inicial) é positiva e maior ou igual à média das variações e qual é a valorização total desses papéis. O valorização de cada papel é o volume vezes a diferença entre a cotação inicial e a cotação corrente. No ficheiro de saída vêm os nomes dos papéis cuja variação é é positiva e a maior que a média, por ordem alfabética, depois a variação média destes papéis e finalmente valorização total também destes papéis. Requisitos técnicos: guarde todas as cotações num saco; ordene os nomes dos papéis usando a função Arrays.sort(). Veja o problema aqui Algoritmos e Estruturas de Dados 24