A apresentação está carregando. Por favor, espere

A apresentação está carregando. Por favor, espere

Estruturas Fundamentais. 2 Sumário Objetivo do Curso Estruturas de Dados Fundamentais Implementação Java A classe Array A classe LinkedList Implementação.

Apresentações semelhantes


Apresentação em tema: "Estruturas Fundamentais. 2 Sumário Objetivo do Curso Estruturas de Dados Fundamentais Implementação Java A classe Array A classe LinkedList Implementação."— Transcrição da apresentação:

1 Estruturas Fundamentais

2 2 Sumário Objetivo do Curso Estruturas de Dados Fundamentais Implementação Java A classe Array A classe LinkedList Implementação C++ A classe Array A classe LinkedList

3 3 Objetivo do Curso Estudo de tipos abstratos de dados tais como Pilhas Filas Deques Listas Árvores Filas de Prioridades etc

4 4 Estruturas de Dados Fundamentais As Estruturas de Dados Fundamentais para a criação dos tipos abstratos de dados são: Arrays Listas Encadeadas

5 5 Características das Linguagens Nenhuma linguagem de programação possui nativa a classe Lista Encadeada. Assim será necessário implementar esta classe. A classe array é nativa de toda linguagem de programação Em C++ não existe expressões sobre arrays. Não se pode passar um array como parâmentro de função nem retornar um array de uma função. Não se pode atribuir o valor de um array a a outro array Na linguagem Java é usual criar uma extensão para a classe Array

6 Implementação Java

7 Classe Array

8 8 Arrays primitivos em Java Os arrays em Java possuem três limitações que seria interessante contornar: Índices sempre vão de 0 até n-1 Não existe atribuição para todo um array O tamanho de um array não pode ser alterado Para contornar estas limitações pode-se definir uma extensão : a classe Array

9 9 Classe Array (extensão a Java) public class Array { protected Object[] data; protected int base; //... }

10 10 Construtores da classe Array public class Array { protected Object[] data; protected int base; public Array (int n, int m) { data = new Object[n]; base = m; } public Array () { this (0, 0); } public Array (int n) { this (n, 0); } //... }

11 11 Método assign public class Array { // cria uma cópia da lista corrente protected Object[] data; protected int base; public void assign (Array array) { if (array != this) { if (data.length != array.data.length) data = new Object [array.data.length]; for (int i = 0; i < data.length; ++i) data [i] = array.data [i]; base = array.base; } //... }

12 12 Métodos getData, getBase e getLength public class Array { protected Object[] data; protected int base; public Object[] getData () { return data; } public int getBase () { return base; } public int getLength () { return data.length; } //... }

13 13 Métodos de indexação get e put public class Array { protected Object[] data; protected int base; public Object get (int position) { return data [position - base]; } public void put (int position, Object object) { data [position - base] = object; } //... }

14 14 Emprego de get e put Caso se desejasse fazer a[2] = b[3] usando a classe Array escrever-se-ia a.getData()[2] = b.getData()[3]; Isto é feio e como não existe sobrecarga de operadores em Java definem-se métodos de indexação get e put obtendo a.put (2, b.get (3));

15 15 Redimensionamento – Métodos setBase e setLength public class Array { protected Object[] data; protected int base; public void setBase (int base) { this.base = base; } public void setLength (int newLength) { if(data.length != newLength) { Object[] newData = new Object[newLength]; int min = data.length < newLength ? data.length : newLength; for(int i = 0; i < min; ++i) newData [i] = data [i]; data = newData; } //... }

16 Classe LinkedList

17 17 Classe LinkedList public class LinkedList { protected Element head; // cabeça protected Element tail; // cauda public final class Element { // elemento do lista Object datum; // dado do elemento ou item Element next; // ponteiro para sucessor Element(Object datum, Element next) { // construtor this.datum = datum; this.next = next; } public Object getDatum() // obter dado { return datum; } public Element getNext() // obter sucessor { return next; } //... } //... }

18 18 Métodos Construtor e purge public class LinkedList { protected Element head; protected Element tail; public LinkedList () // construir uma lista {} public void purge () // esvaziar uma lista { head = null; tail = null; } //... }

19 19 Métodos getHead, getTail e isEmpty public class LinkedList { protected Element head; protected Element tail; public Element getHead () // cabeça da lista { return head; } public Element getTail () // cauda da lista { return tail; } public boolean isEmpty () //teste de lista vazia { return head == null; } //... }

20 20 Métods getFirst e getLast public class LinkedList { protected Element head; protected Element tail; public Object getFirst() { // obter o primeiro elemento //da lista if(head == null) throw new ContainerEmptyException(); return head.datum; } public Object getLast() {// obter o último elemento //da lista if(tail == null) throw new ContainerEmptyException(); return tail.datum; } //... }

21 21 Método prepend public class LinkedList { protected Element head; protected Element tail; // inluir o objeto item no início da lista corrente public void prepend(Object item) { Element tmp = new Element(item, head); if(head == null) tail = tmp; head = tmp; } //... }

22 22 Método append public class LinkedList { protected Element head; protected Element tail; // incluir o objeto item no final da lista corrente public void append (Object item) { Element tmp = new Element (item, null); if(head == null) head = tmp; else tail.next = tmp; tail = tmp; } //... }

23 23 Método assign public class LinkedList { protected Element head; protected Element tail; // a lista list será uma cópia da lista corrente public void assign(LinkedList list) { if(list != this) { purge (); for(Element ptr = list.head; ptr != null; ptr = ptr.next) { append (ptr.datum); } //... }

24 24 Método extract (1) public class LinkedList { protected Element head; protected Element tail; // Exclui objeto item public void extract(Object item) { Element ptr = head; Element prevPtr = null; while(ptr != null && ptr.datum != item) { prevPtr = ptr; ptr = ptr.next; }

25 25 Método extract (2) if(ptr == null) throw new IllegalArgumentException("item not found"); if(ptr == head) head = ptr.next; else prevPtr.next = ptr.next; if(ptr == tail) tail = prevPtr; } //... }

26 26 Métodos insertAfter e insertBefore (1) public class LinkedList { protected Element head; protected Element tail; public final class Element { Object datum; Element next; // Inclui item depois do objeto corrente public void insertAfter(Object item) { next = new Element (item, next); if(tail == this) tail = next; }

27 27 Métodos insertAfter e insertBefore (2) // Inclui item antes do objeto corrente public void insertBefore(Object item) { Element tmp = new Element(item, this); if(this == head) head = tmp; else { Element prevPtr = head; while(prevPtr != null && prevPtr.next != this) prevPtr = prevPtr.next; prevPtr.next = tmp; } //... } //... }

28 Implementação C++

29 Classe Array

30 30

31 31 Definição da Classe Array (1) // pgm04_01.cpp template class Array { protected: T* data; unsigned int base; unsigned int length; public: Array(); Array(unsigned int, unsigned int = 0); ~Array(); Array(Array const&); Array& operator = (Array const&);

32 32 Definição da Classe Array (2) // pgm04_01.cpp (Continuação) T const& operator [] (unsigned int) const; T& operator [] (unsigned int); T const* Data () const; unsigned int Base () const; unsigned int Length () const; void SetBase (unsigned int); void SetLength (unsigned int); };

33 33 O Construtor Default da Classe Array // pgm04_02.cpp template Array ::Array () : data (new T [0]), base (0), length (0) {}

34 34 Definição do Construtor com tamanho da Classe Array // pgm04_03.cpp template Array ::Array (unsigned int n, unsigned int m) : data (new T [n]), base (m), length (n) {}

35 35 Construtor Copy da Classe Array // pgm04_04.cpp template Array ::Array (Array const& array) : data (new T [array.length]), base (array.base), length (array.length) { for(unsigned int i = 0; i < length; ++i) data [i] = array.data [i]; }

36 36 Destrutor da Classe Array // pgm04_05.cpp template Array ::~Array () { delete [] data; }

37 37 Definição de Funções Accessor da Classe Array // pgm04_06.cpp template T const* Array ::Data () const { return data; } template unsigned int Array ::Base () const { return base; } template unsigned int Array ::Length () const { return length; }

38 38 Definição de Função Operador subscrito da Classe Array // pgm04_07.cpp template T const& Array ::operator [] (unsigned int position) const { unsigned int const offset = position - base; if(offset >= length) throw out_of_range ("invalid position"); return data [offset]; } template T& Array ::operator [] (unsigned int position) { unsigned int const offset = position - base; if (offset >= length) throw out_of_range ("invalid position"); return data [offset]; }

39 39 Redimensionamento de arrays // pgm04_08.cpp template void Array ::SetBase (unsigned int newBase) { base = newBase; } template void Array ::SetLength (unsigned int newLength) { T* const newData = new T [newLength]; unsigned int const min = length < newLength ? length : newLength; for(unsigned int i = 0; i < min; ++i) newData [i] = data [i]; delete [] data; data = newData; length = newLength; }

40 Classe LinkedList

41 41 Implementação

42 42 Definição das Classes LinkedList e ListElement (1) // pgm04_09.cpp template class LinkedList; template class ListElement { T datum; ListElement* next; ListElement (T const&, ListElement*); public: T const& Datum () const; ListElement const* Next () const; friend LinkedList ; };

43 43 Definição das Classes LinkedList e ListElement (2) // pgm04_09.cpp (Continuação) template class LinkedList { ListElement * head; ListElement * tail; public: LinkedList (); ~LinkedList (); LinkedList (LinkedList const&); LinkedList& operator = (LinkedList const&);

44 44 Definição das Classes LinkedList e ListElement (3) // pgm04_09.cpp (Continuação) ListElement const* Head () const; ListElement const* Tail () const; bool IsEmpty () const; T const& First () const; T const& Last () const; void Prepend (T const&); void Append (T const&); void Extract (T const&); void Purge (); void InsertAfter (ListElement const*, T const&); void InsertBefore (ListElement const*, T const&); };

45 45 Definição de Funções Membro da Classe ListElement // pgm04_10.cpp template ListElement ::ListElement ( T const& _datum, ListElement * _next) : datum (_datum), next (_next) {} template T const& ListElement ::Datum () const { return datum; } template ListElement const* ListElement ::Next () const { return next; }

46 46 Construtor Default da Classe ListElement // pgm04_11.cpp template LinkedList ::LinkedList () : head (0), tail (0) {}

47 47 Definição de Funções Membro Destrutor e Purge da Classe ListElement // pgm04_12.cpp template void LinkedList ::Purge () { while (head != 0) { ListElement * const tmp = head; head = head->next; delete tmp; } tail = 0; } template LinkedList ::~LinkedList () { Purge (); }

48 48 Definição de Funções Accessor da Classe ListElement // pgm04_13.cpp template ListElement const* LinkedList ::Head () const { return head; } template ListElement const* LinkedList ::Tail () const { return tail; } template bool LinkedList ::IsEmpty () const { return head == 0; }

49 49 Definição de Funções First e Last da Classe ListElement // pgm04_14.cpp template T const& LinkedList ::First () const { if(head == 0) throw domain_error ("list is empty"); return head->datum; } template T const& LinkedList ::Last () const { if(tail == 0) throw domain_error ("list is empty"); return tail->datum; }

50 50 Definição de Função Prepend da Classe ListElement // pgm04_15.cpp template void LinkedList ::Prepend (T const& item) { ListElement * const tmp = new ListElement (item, head); if(head == 0) tail = tmp; head = tmp; }

51 51 Definição de Função Append da Classe ListElement // pgm04_16.cpp template void LinkedList ::Append (T const& item) { ListElement * const tmp = new ListElement (item, 0); if(head == 0) head = tmp; else tail->next = tmp; tail = tmp; }

52 52 Definição de Função Construtor Copy da Classe ListElement (1) // pgm04_17.cpp template LinkedList ::LinkedList (LinkedList const& linkedList) : head (0), tail (0) { ListElement const* ptr; for(ptr = linkedList.head; ptr != 0; ptr = ptr->next) Append (ptr->datum); }

53 53 Definição de Função Construtor Copy da Classe ListElement (2) template LinkedList & LinkedList ::operator = (LinkedList const& linkedList) { if(&linkedList != this) { Purge (); ListElement const* ptr; for(ptr = linkedList.head; ptr != 0; ptr = ptr->next) Append (ptr->datum); } return *this; }

54 54 Definição de Função Extract da Classe ListElement (1) // pgm04_18.cpp template void LinkedList ::Extract (T const& item) { ListElement * ptr = head; ListElement * prevPtr = 0; while(ptr != 0 && ptr->datum != item) { prevPtr = ptr; ptr = ptr->next; }

55 55 Definição de Função Extract da Classe ListElement (2) // pgm04_18.cpp (Continuação) if(ptr == 0) throw invalid_argument ("item not found"); if(ptr == head) head = ptr->next; else prevPtr->next = ptr->next; if(ptr == tail) tail = prevPtr; delete ptr; }

56 56 Definição de Funções InsertAfter e InsertBefore da Classe ListElement (1) // pgm04_19.cpp template void LinkedList ::InsertAfter (ListElement const* arg, T const& item) { ListElement * ptr = const_cast *> (arg); if(ptr == 0) throw invalid_argument ("invalid position"); ListElement * const tmp = new ListElement (item, ptr->next); ptr->next = tmp; if(tail == ptr) tail = tmp; }

57 57 Definição de Funções InsertAfter e InsertBefore da Classe ListElement (2) template void LinkedList ::InsertBefore (ListElement const* arg, T const& item) { ListElement * ptr = const_cast *> (arg); if(ptr == 0) throw invalid_argument ("invalid position"); ListElement * const tmp = new ListElement (item, ptr);

58 58 Definição de Funções InsertAfter e InsertBefore da Classe ListElement (3) if(head == ptr) head = tmp; else { ListElement * prevPtr = head; while(prevPtr != 0 && prevPtr->next != ptr) prevPtr = prevPtr->next; if(prevPtr == 0) throw invalid_argument ("invalid position"); prevPtr->next = tmp; }

59 Arrays Multi dimensionais

60 60 Cálculo de índice

61 61 Definição das Classes Array2D e Array2D ::Row (1) // pgm04_20.cpp template class Array2D { protected: unsigned int numberOfRows; unsigned int numberOfColumns; Array array;

62 62 Definição das Classes Array2D e Array2D ::Row (2) public: class Row { Array2D& array2D; unsigned int const row; public: Row(Array2D& _array2D, unsigned int _row) : array2D (array2D), row(row) {} T& operator [] (unsigned int column) const { return array2D.Select (row, column); } }; Array2D (unsigned int, unsigned int); T& Select (unsigned int, unsigned int); Row operator [] (unsigned int); };

63 63 Funções Membro da Classe Classes Array2D (1) // pgm04_21.cpp template Array2D ::Array2D (unsigned int m, unsigned int n) : numberOfRows (m), numberOfColumns (n), array (m * n) {}

64 64 Funções Membro da Classe Classes Array2D (2) // pgm04_21.cpp (Continuação) template T& Array2D ::Select (unsigned int i, unsigned int j) { if (i >= numberOfRows) throw out_of_range ("invalid row"); if (j >= numberOfColumns) throw out_of_range ("invalid column"); return array [i * numberOfColumns + j]; } template Array2D ::Row Array2D ::operator [] (unsigned int row) { return Row (*this, row); }

65 65 Índices Multi dimensionais em C++ A função membro operator[] de Array2D serve para indexar e constrói uma instância da classe Array2D ::Row Como exemplo pode-se declarar um array de inteiros e inicializar com o valor zero todos os seus membros da maneira que se segue. Array2D a (4, 5); for (int i = 0; i < 4; ++i) for (int j = 0; j < 5; ++j) a[i][j] = 0;

66 66 Multiplicação canônica de matrizes Dadas as Matrizes A(m x n) e B(n x p) seu produto C =AB tem dimensões m x p

67 67 Definição da Classe Matrix // pgm04_22.cpp template class Matrix : public Array2D { public: Matrix (unsigned int, unsigned int); Matrix operator * (Matrix const&) const; Matrix operator + (Matrix const&) const; };

68 68 Classe Matrix - Operador de Multiplicação // pgm04_23.cpp template Matrix Matrix ::operator * (Matrix const& arg) const { if(numberOfColumns != arg.numberOfRows) throw invalid_argument ("incompatible matrices"); Matrix result (numberOfRows, arg.numberOfColumns); for(unsigned int i = 0; i < numberOfRows; ++i) { for(unsigned int j = 0; j < arg.numberOfColumns; ++j){ T sum = 0; for(unsigned int k = 0; k < numberOfColumns; ++k) sum += (*this) [i][k] * arg [k][j]; result [i][j] = sum; } return result; }

69 Interfaces das estruturas já vistas

70 70 Pilhas public interface Stack extends Container { Object getTop (); void push (Object object); Object pop (); }

71 71 Filas public interface Queue extends Container { Object getHead (); void enqueue (Object object); Object dequeue (); }

72 72 Deques public interface Deque extends Container { Object getHead (); Object getTail (); void enqueueHead (Object object); void enqueueTail (Object object); Object dequeueHead (); Object dequeueTail (); }


Carregar ppt "Estruturas Fundamentais. 2 Sumário Objetivo do Curso Estruturas de Dados Fundamentais Implementação Java A classe Array A classe LinkedList Implementação."

Apresentações semelhantes


Anúncios Google