1 / 110

Listas Ordenadas e Listas Classificadas

Listas Ordenadas e Listas Classificadas. Sumário. Fundamentos Listas Ordenadas Listas Classificadas. Conceito de Listas. Listas são os containers mais simples que existem e também os mais versáteis.

dalit
Download Presentation

Listas Ordenadas e Listas Classificadas

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Listas Ordenadas e Listas Classificadas

  2. Sumário • Fundamentos • Listas Ordenadas • Listas Classificadas

  3. Conceito de Listas • Listas são os containers mais simples que existem e também os mais versáteis. • Consideradas como tipos abstratos de dados listas são séries de itens e permitem inclusão e exclusão de elementos e a visitação a itens na ordem em que aparecem.

  4. Tipos especiais de Listas • Podem ser definidos dois tipos especiais de listas: • Listas ordenadas – são aquelas nas quais a ordem ou posição dos itens é relevante, independentemente de seu conteúdo e, portanto, pode ser modificada. • Listas classificadas – são listas ordenadas nas quais a ordem é inerente ao conteúdo dos itens e não pode ser modificada. • As abstrações destes tipos de listas são encontradas nas interfaces OrderedList e SortedList.

  5. Interfaces OrderedList e SortedList

  6. Fundamentos • Considerar-se-ão como fundamentos os padrões de Projeto e as Hierarquias de classe, ou Framework, de Bruno Preiis. • Em particular as interfaces • Comparable • Container • SearchableContainer

  7. Implementação Java

  8. 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); }

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

  10. 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; } // ... }

  11. Interface SearchableContainer public interface SearchableContainer extends Container { boolean isMember(Comparable object); void insert(Comparable object); void withdraw(Comparable obj); Comparable find(Comparable object); }

  12. Listas Ordenadas

  13. Listas Ordenadas - Sumário • Introdução • Implementação sobre “Arrays” • Implementação sobre Listas Encadeadas

  14. Introdução • As listas Ordenadas serão apresentadas por uma interface e duas classes correspondendo a dois tipos de implementação, sobre “arrays” e sobre listas encadeadas: • Interface OrderedList • Classe OrderedListAsArray • Classe OrderedListAsLinkedList

  15. Interface OrderedList public interface OrderedList extends SearchableContainer { Comparable get (int i); Cursor findPosition (Comparable object); }

  16. Interface OrderedList • Esta interface estende SearchableContainer e apresenta os métodos get e findPosition. Por sua vez SearchableContainer dispõe dos métodos: • insert • withdraw • find • isMember

  17. Método findPosition de OrderedList • O método findPosition retorna um Cursor, cuja interface será exibida a seguir e que dispõe dos métodos: • getDatum • insertAfter • insertBefore • withdraw

  18. Interface Cursor public interface Cursor { Comparable getDatum(); void insertAfter(Comparable object); void insertBefore(Comparable object); void withdraw(); }

  19. Interface SortedList public interface SortedList extends SearchableContainer { Comparable get(int i); Cursor findPosition(Comparable object); }

  20. Implementação sobre “Arrays”

  21. Classe OrderedListAsArray public class OrderedListAsArray extends AbstractSearchableContainer implements OrderedList { protected Comparable[] array; // ... }

  22. Construtor e método de inserção de item no final da lista public class OrderedListAsArray extends AbstractSearchableContainer implements OrderedList { protected Comparable[] array; public OrderedListAsArray(int size) { array = new Comparable [size]; } public void insert(Comparable object) { if(count == array.length) throw new ContainerFullException (); array[count] = object; ++count; } // ... }

  23. Métodos isMember e find public class OrderedListAsArray extends AbstractSearchableContainer implements OrderedList { protected Comparable[] array; public boolean isMember(Comparable object) { for(int i = 0; i < count; ++i) if(array[i] == object) return true; return false; } public Comparable find(Comparable arg) { for(int i = 0; i < count; ++i) if(array[i].isEQ(arg)) return array[i]; return null; } // ... }

  24. Método withdraw (1) public class OrderedListAsArray extends AbstractSearchableContainer implements OrderedList { protected Comparable[] array; public void withdraw(Comparable object) { if(count == 0) throw new ContainerEmptyException (); int i = 0; while(i < count && array[i] != object) ++i; if(i == count) throw new IllegalArgumentException("objeto não encontrado");

  25. Método withdraw (2) for( ; i < count - 1; ++i) array[i] = array[i + 1]; array[i] = null; --count; } // ... }

  26. Posição de um item em uma lista por meio da Classe Interior OrderedListAsArray.MyCursor (1) public class OrderedListAsArray extends AbstractSearchableContainer implements OrderedList { protected Comparable[] array; protected class MyCursor implements Cursor { int offset; MyCursor (int offset) { this.offset = offset; }

  27. Posição de um item em uma lista por meio da Classe Interior OrderedListAsArray.MyCursor (2) public Comparable getDatum() { if(offset < 0 || offset >= count) throw new IndexOutOfBoundsException(); return array [offset]; } // ... } // ... }

  28. Busca de um item e acesso por posiçãoMétodos findPosition e get de OrderedListAsArray public class OrderedListAsArray extends AbstractSearchableContainer implements OrderedList { protected Comparable[] array; public Cursor findPosition(Comparable object) { int i = 0; while(i < count && array[i].isNE(object)) ++i; return new MyCursor(i); } public Comparable get(int offset) { if(offset < 0 || offset >= count) throw new IndexOutOfBoundsException(); return array[offset]; } // ... }

  29. Inserção de itens em posições arbitrárias Métodos insertBefore e insertAfter de OrderedListAsArray

  30. Método insertAfter (1) public class OrderedListAsArray extends AbstractSearchableContainer implements OrderedList { protected Comparable[] array; protected class MyCursor implements Cursor { int offset;

  31. Método insertAfter (2) public void insertAfter (Comparable object) { if(offset < 0 || offset >= count) throw new IndexOutOfBoundsException(); if(count == array.length) throw new ContainerFullException(); int insertPosition = offset + 1; for(int i = count; i > insertPosition; --i) array[i] = array[i - 1]; array[insertPosition] = object; ++count; } // ... } // ... }

  32. Método insertBefore (1) public class OrderedListAsArray extends AbstractSearchableContainer implements OrderedList { protected Comparable[] array; protected class MyCursor implements Cursor { int offset;

  33. Método insertBefore (2) public void insertBefore(Comparable object) { if(offset < 0 || offset >= count) throw new IndexOutOfBoundsException(); if(count == array.length) throw new ContainerFullException(); int insertPosition = offset; for(int i = count; i > insertPosition; --i) array[i] = array[i - 1]; array[insertPosition] = object; ++count; } // ... } // ... }

  34. Exclusão de itens em posições arbitrárias Método withdraw de OrderedListAsArray

  35. Método withdraw (1) public class OrderedListAsArray extends AbstractSearchableContainer implements OrderedList { protected Comparable[] array; protected class MyCursor implements Cursor { int offset;

  36. Método withdraw (2) public void withdraw() { if(offset < 0 || offset >= count) throw new IndexOutOfBoundsException(); if(count == 0) throw new ContainerEmptyException(); int i = offset; while(i < count - 1) { array[i] = array[i + 1]; ++i; } array[i] = null; --count; } // ... } // ... }

  37. Implementação sobre Listas Encadadeadas

  38. Métodos da classe LinkedList • getDatum • getNext • Construtor e purge • getHead • getTail • isEmpty • getFirst • getLast • prepend • append • assign • extract • insertAfter • insertBefore

  39. Classe OrderedListAsLinkedList public class OrderedListAsLinkedList extends AbstractSearchableContainer implements OrderedList { protected LinkedList linkedList; // ... }

  40. Construtor e métodos de inserção de objeto (1) public class OrderedListAsLinkedList extends AbstractSearchableContainer implements OrderedList { protected LinkedList linkedList; public OrderedListAsLinkedList() { linkedList = new LinkedList(); } public void insert(Comparable object) { linkedList.append(object); ++count; }

  41. Construtor e métodos de inserção de objeto (2) public Comparable get(int offset) { if(offset < 0 || offset >= count) throw new IndexOutOfBoundsException(); LinkedList.Element ptr = linkedList.getHead(); for(int i = 0; i < offset && ptr != null; ++i) ptr = ptr.getNext(); return (Comparable) ptr.getDatum(); } // ... }

  42. Métodos isMember e find (1) public class OrderedListAsLinkedList extends AbstractSearchableContainer implements OrderedList { protected LinkedList linkedList; public boolean isMember (Comparable object) { for(LinkedList.Element ptr = linkedList.getHead(); ptr != null; ptr = ptr.getNext()) { if((Comparable) ptr.getDatum() == object) return true; } return false; }

  43. Métodos isMember e find (2) public Comparable find (Comparable arg) { for(LinkedList.Element ptr = linkedList.getHead(); ptr != null; ptr = ptr.getNext()) { Comparable object = (Comparable) ptr.getDatum(); if(object.isEQ(arg)) return object; } return null; } // ... }

  44. Método withdraw public class OrderedListAsLinkedList extends AbstractSearchableContainer implements OrderedList { protected LinkedList linkedList; public void withdraw (Comparable object) { if(count == 0) throw new ContainerEmptyException(); linkedList.extract(object); --count; } // ... }

  45. Classe Interior OrderedListAsLinkedList.MyCursor public class OrderedListAsLinkedList extends AbstractSearchableContainer implements OrderedList { protected LinkedList linkedList; protected class MyCursor implements Cursor { LinkedList.Element element; MyCursor(LinkedList.Element element) { this.element = element; } public Comparable getDatum() { return (Comparable) element.getDatum(); } // ... } // ... }

  46. Busca de um item e acesso por posição Método findPosition public class OrderedListAsLinkedList extends AbstractSearchableContainer implements OrderedList { protected LinkedList linkedList; public Cursor findPosition (Comparable arg) { LinkedList.Element ptr; for(ptr = linkedList.getHead(); ptr != null; ptr = ptr.getNext()) { Comparable object = (Comparable) ptr.getDatum(); if(object.isEQ(arg)) break; } return new MyCursor (ptr); } // ... }

  47. Método insertAfter public class OrderedListAsLinkedList extends AbstractSearchableContainer implements OrderedList { protected LinkedList linkedList; protected class MyCursor implements Cursor { LinkedList.Element element; public void insertAfter (Comparable object) { element.insertAfter(object); ++count; } // ... } // ... }

  48. Exclusão de item correnteMétodo withdraw public class OrderedListAsLinkedList extends AbstractSearchableContainer implements OrderedList { protected LinkedList linkedList; protected class MyCursor implements Cursor { LinkedList.Element element; public void withdraw() { linkedList.extract(element.getDatum()); --count; } // ... } // ... }

  49. Listas Classificadas

  50. Listas Classificadas - Sumário • Introdução • Implementação sobre “Arrays” • Implementação sobre Listas Encadeadas

More Related