Algoritmos e Estruturas de Dados 1

Transcrição

1 1. Algoritmos e Estruturas de Dados 1 Época Normal - 21 Janeiro 2005 public class Data private int dia, mes, ano; public Data(int d, int m, int dia = d; mes = m; ano = a; public Data(int d, int m) this(d, m, 1900); public Data(int d) this(d, 1); public Data() this(1); resolução public String tostring() return dia + "/" + mes + "/" + ano; b) public class DataEx extends Data public DataEx(int d, int m, int throws Exception super(d, m, ; if (d > 31) throw new Exception("Dia incorrecto"); if (m > 12) throw new Exception("Mes incorrecto"); public DataEx(int d, int m) throws Exception this(d, m, 1900); public DataEx(int d) throws Exception this(d, 1); public DataEx() throws Exception this(1); c) public class Teste static void main() throws Exception // Aqui não se necessita de try, o método main() declara que // "passa" a excepção. DataEx d11 = new DataEx(5, 12, 2000); System.out.println(d11); // imprime: 5/12/2000 try d11 = new DataEx(33, 12, 2005); System.out.println(d11); // imprime: 33/12/2005? catch (Exception e) System.out.println(e); finally // isto é *sempre* impresso, quer haja ou não excepção System.out.println(d11 + ": 5/12 ou 33/12?"); 1/7

2 d) i) Não é assinalado nenhum erro ou aviso. Um objecto de uma subclasse *É* um objecto da super classe; um Aluno *É* uma Pessoa, um DataEx *É* um Data. Além disso d1 é uma referência para o objecto, não é o objecto ii) É impresso DataEx. Em *tempo de execução* o intérprete Java chama o método da classe a que o objecto pertence (note-se que d1 é uma referência para o objecto, não o objecto). A esta propriedade chama-se polimorfismo -- o que tem muitas formas. Podemos ter por exemplo um array de Pessoas, em que um elemento do array é um Aluno, outro é um Professor, outro um Funcionário [ luís,4], [ sarmento,2], [ ana,27], [ rocha,5], [ gil,1], [ gonçalves,13], [ joão,22], [ cardoso,7] O primeiro ponto que teremos que decidir é qual a estatégia de escolha do pivot. Há várias possibilidades em jogo: 1. Estratégia 1: Escolher como pivot o primeiro ou o último elemento da lista, o que é aceitável se a lista está perfeitamente baralhda mas que se revela muito ineficiente quando a lista está parcialmente ordenada; 2. Estratégia 2: Escolher o elemento central da lista, o que é razoável mas pode levar a maus resultados pois depende muito do estado inicial da lista; 3. Estratégia 3: Mediana-de-três. Esta estratégia tem como objectivo aumentar a observação do estado da lista, usando uma amostra de 3 valores para se poder fazer uma escolha mais informada. Escolhe-se a mediana dos três valores (o valor do meio, depois de ordenar os 3 valores). Pergunta para pensar: será que aumentando a amostra, por exemplo para 5 elementos, se melhora ainda mais a escolha do pivot? É significativo? Iremos utililizar a Estratégia 3, já que é a mais aconselhada. As outra duas levam a que o algoritmo de ordenação tenha de executar mais chamadas recursivas, degradando assim o desempenho. 1) Lista inicial (iremos apenas considerar as cadeias de caracteres): L0 = luís, sarmento, ana, rocha, gil, gonçalves, joão, cardoso Candidatos a pivot: luis, rocha, cardoso Ordenando e seleccionado a mediana: cardoso, luis, rocha -> pivot: luís Reposicionando na lista os 3 elementos, ainda antes de iniciar a pivotação (com low=0, middle=3 e high=7, ver página 310 do livro do Weiss!): L0 = cardoso, sarmento, ana, luis, gil, gonçalves, joão, rocha Trocando o pivot com high-1 ( 6 -> joão): L0 = cardoso, sarmento, ana, joão, gil, gonçalves, luis, rocha /7

3 Avancando i ( = 0) a partir da esquerda e j a partir da direita (i.e. do pivot -> 6). Paramos com: i =1 (sarmento > pivot) e j = 5 (gonçalves < pivot): Devemos então trocar i com j: L0 = cardoso, gonçalves, ana, joão, gil, sarmento, luis, rocha Avançando i e j, vemo-nos obrigados a parar na presença de um cruzamento das referências: i = 5 (sarmento) e j = 4 (gonçalves) Devemos simplesmente parar e recolocar o pivot na sua posição, ou seja trocar i (5) com high-1 (6) : L0 = cardoso, gonçalves, ana, joão, gil, luis, sarmento, rocha Podemos agora dividir a lista inicial em duas sub-lista, uma que inclui todos os elementos menores que o pivot (< luis) e outra contendo os elementos maiores ( > luis). L1 = L(0,4) = cardoso, gonçalves, ana, joão, gil L2 = L(6,7) = sarmento, rocha Por ter apenas dois elementos, a lista L2 possui uma ordenação trivial pelo que não iremos considerar o seu processo de ordenção. O resultado é obviamente rocha, sarmento. Vamos sim aplicar o algoritmo Quicksort à lista L1. Começemos por escolher um pivot apropriado. Os candidatos a pivot são: cardoso, ana, gil Ordenando e seleccionado a mediana: ana, cardoso, gil -> pivot: cardoso Reposicionando na lista os 3 elementos antes da pivotação (low=0, middle=2 e high=4): L1 = ana, gonçalves, cardoso, joão, gil Trocando o pivot com high-1 ( 3 -> joão): L1 = ana, gonçalves, joão, cardoso, gil Vamos então a pivotear, avancando i (0) a partir da esquerda e j a partir da direita (i.e. posição do pivot -> 3). Paramos com i =1 (gonçalves > pivot) e j = 0 (ana < pivot). As referências i e j cruzam-se pelo que termina a pivotação. Reposicionando o pivot, ou seja trocando i (=1) com high-1 (3) : L1 = ana, cardoso, joão, gonçalves, gil Podemos agora partir a lista em duas outras, contendo os elementos menores e os elementos maiores que o pivot usado: L3 = ana L4 = joão, gonçalves, gil Temos agora dois casos triviais. No caso da L4, o ordenação termina com a escolha do pivot, ficando L4 ordenada desta forma: gil, gonçalves joão. A lista inicial L0 encontra-se agora correctamente ordenada. Vejamos: L0 = L3 cardoso L4 luis L2 = ana, cardoso, joão, gonçalves, gil, luis, rocha, sarmento 3/7

4 b) Para escolher o N-ésimo elemento da lista, não precisamos de ordenar a lista. Basta-nos impor uma pequena variação no Quicksort, transformando-o num algoritmo conhecido como Quickselect. Ao contrário de fazer uma completa ordenação da lista, o Quickselect tenta executar partições sucessivas no sentido de delimitar a posição do N-esimo maior (ou menor) elemento que procuramos. Assim, o algoritmo começa por executar uma pivotação tal como no Quicksort, mas no momento anterior à chamada recursiva testa a posição do pivot para saber se o N-ésimo elemento em causa se encontra à esquerda ou direita do pivot, ou se é o próprio pivot. Note-se que, tal como no Quicksort, após o processo de pivotação o pivot encontra-se já na posição que terá no final da ordenação. Assim sendo, se o pivot se encontrar na posição P poderemos considerar 3 situações: 1. se P = N então o pivot é o elemento que procuramos: terminamos a pesquisa! 2. se N < P o elemento que procurámos encontra-se à esquerda do pivot, na sub-lista dos menores 3. se N > P o elemento que procurámos encontra-se à direita do pivot, na sub-lista dos maiores Nos casos 2 e 3 poderemos prosseguir o algoritmo considerando apenas uma das sub-listas: o problema fica dividido a meio (atenção: não é bem a meio como veremos!). Podemos também considerar que o caso 1 é equivalente a uma pesquisa numa sub-lista de tamanho 0 para não termos de lidar em especial com este caso. Vamos então tentar ver qual a ordem de complexidade envolvida (adaptado de Weiss, p. 301). Comecemos por verificar que a escolha do pivot raramente leva a uma divisão exacta da lista a ordenar em duas sub-lista de metade do tamanho da inicial (Pergunta para pensar: se isso acontecesse, o processo de encontrar o N-ésimo elemento seria semelhante à pesquisa numa outra estrutura de dados que estudamos. Qual é essa estrutura e que consequencias isso teria na ordem de complexidade desta selecção?). Como tal poderemos dizer que para a sub-lista esquerda e para a sub-lista direita teremos um custo médio que pode ser equacionado por... T(E) = T(D) = [T(0) + T(1) + T(2) T(N-1)] / N (Eq.1)...porque poderemos ter equiprovavelmente sub-listas com tamanhos que variam entre 0 até N-1 dependendo se o pivot nos for muito ou pouco favorável (ver exercício anterior). A vantagem do Quickselect é que poderemos considerar apenas uma das sub-listas (a vazia, a esquerda ou a direita dependendo da situação em causa 1 ou 2,3). Assim, teremos para o Quickselect em termos médios: T(N) = [T(0) + T(1) + T(2) T(N-1)] / N + N (Eq. 2) sendo N um custo linear envolvido na partição. Podemos então fazer: N * T(N) = [T(0) + T(1) + T(2) T(N-1)] + N^2 (Eq. 3) Para N-1 teremos: (N -1) * T(N-1) = [T(0) + T(1) + T(2) T(N-2)] + (N-1)^2 (Eq. 4) Fazendo (Eq.3) (Eq.4) obtemos: N * T(N) - (N -1) * T(N-1) = T(N-1) + N^2 - (N 1)^2 O que, simplificando, permite obter: N * T(N) = N * T(N-1) + 2*N - 1 Ignorando o termo constante e dividindo por N: T(N) = T(N-1) + 2 O que nos leva a uma ordem de grandeza em média de O(n), como poderemos explicitar por: T(N) = T(N-1) + 2 T(N-1) = T(N-2) + 2 T(N-2) = T(N-3) + 2 T(2) = T(1) + 2 = Somando T(N) = (N-2) * = 2* N - 2 e logo O(N)! 4/7

5 3. // BoundedArrayQueue class // CONSTRUCTION: with initializer // // ******************PUBLIC OPERATIONS********************* // void enqueue( x ) --> Insert x // Object getfront( ) --> Return least recently inserted item // Object dequeue( ) --> Return and remove least recent item // boolean isempty( ) --> Return true if empty; else false // void makeempty( ) --> Remove all items // boolean isfull( ) --> Return true if full; else false // ******************ERRORS******************************** // getfront or dequeue on empty queue // enqueue on full queue * Array-based implementation of the bounded capacity queue. public class BoundedArrayQueue implements Queue * Construct the queue. public BoundedArrayQueue(int capacity) thearray = new Object[ capacity ]; thecapacity = capacity; makeempty( ); * Test if the queue is logically full. true if full, false otherwise. public boolean isfull( ) return currentsize == thecapacity; * Insert a new item into the queue. x the item to insert. 5/7

6 public void enqueue( Object x ) if( isfull( ) ) throw new OverflowException( "BoundedArrayQueue enqueue" ); back = increment( back ); thearray[ back ] = x; currentsize++; * Internal method to increment with wraparound. x any index in thearray's range. x+1, or 0 if x is at the end of thearray. private int increment( int x ) if( ++x == thearray.length ) x = 0; return x; private Object [ ] thearray; private int thecapacity; private int currentsize; private int front; private int back; * Exception class for access in full containers * such as stacks, queues, and priority queues. public class OverflowException extends RuntimeException * Construct this exception object. message the error message. public OverflowException( String message ) super( message ); b) O método kfaz combina dois objectos do tipo Queue (duas filas) num novo objecto Queue alternando a ordem dos elementos, à medida que esvazia q1 e q2. c) Implementação com lista ligada: mais natural para filas não limitadas; não necessita de métodos auxiliares para aumentar tamanho; não necessita de métodos auxiliares para manter apontadores de front e back. 6/7

7 4. public class Clube implements Comparable private String nome; private int pontuacao, njganhos, njperdidos, njempates; private int ngmarcados, ngsofridos; public Clube (String nm) nome=new String (nm); pontuacao=0; njganhos=njperdidos=njempates=0; ngmarcados=ngsofridos=0; public int compareto(comparable obj) // necessário para operações inserção/pesquisa/remoção na BinarySearchTree Clube c1 = (Clube) obj; if (pontuacao!= c1.pontuacao) return (pontuacao-c1.pontuacao); int difgolos = ngmarcados-ngsofridos; int difgolos1 = c1.ngmarcados-c1.ngsofridos; if (difgolos!= difgolos1) return (difgolos-difgolos1); return (nome.compareto(c1.nome)); b) void actualiza (BinarySearchTree campeonato, Clube c1, Clube c2, int golosc1, int golosc2) campeonato.remove(c1); campeonato.remove(c2); c1.actualizapontuacao(golosc1,golosc2); c1.actualizapontuacao(golosc2,golosc1); campeonato.insert(c1); campeonato.insert(c2); Na classe Clube, é necessário implementer o método actualizapontuacao void actualizapontuacao(int golosmarcados, int golossofridos) if (golosmarcados>golossofridos) pontuacao += 3; njganhos++; else if (golosmarcados==golossofridos) pontuacao += 1; njempates++; else njperdidos++; ngmarcados += golosmarcados; ngsofridos += golossofridos; 7/7