CAP-241 Computação Aplicada I Aula 5 Estruturas de Dados Elementares Parte I Arranjos, Listas, Pilhas e Filas. Dr. Gilberto Ribeiro de Queiroz

Transcrição

1 CAP-241 Computação Aplicada I Aula 5 Estruturas de Dados Elementares Parte I Arranjos, Listas, Pilhas e Filas Dr. Gilberto Ribeiro de Queiroz São José dos Campos, 14 de Abril de 2016

2 Visão Geral da Aula Estruturas de dados Elementares: Listas. Pilhas. Filas. Árvores. Filas de Prioridade Containers da Biblioteca STL Considerações Finais. Leituras Complementares. Exercícios.

3 Estruturas de Dados Assim como na matemáwca, conjuntos possuem um papel importante na Ciência da Computação: A diferença básica, é que os conjunto manipulados por algoritmos podem crescer ou diminuir com o tempo, ou até mesmo modificar os valores de itens. Conjuntos em computação possuem uma natureza dinâmica. O projeto de algoritmos, quase sempre, depende de algum Wpo de representação para o conjunto de dados, seja ele de entrada ou saída, ou até mesmo um conjunto manwdo de forma temporária durante o processamento do algoritmo. Além disso, cada algoritmo possui seus requisitos na hora de manipular conjuntos.

4 Estruturas de Dados Exemplo: Um famoso algoritmo para computação dos pontos de intersecção entre conjuntos de segmentos de reta, precisa de um conjunto auxiliar para: ü Inserir eventos, que representam pontos extremos dos segmentos ou pontos de intersecção já detectados; ü Obter o evento com menor valor de abscissa (ou ordenada); ü Remover eventos já processados; ü Verificar se um dado evento já se encontra no conjunto.

5 Estruturas de Dados Uma das técnicas fundamentais para construção de bons algoritmos consiste em organizar o conjunto de dados manipulados de forma que as operações sobre esses dados sejam realizadas de forma eficiente. As estruturas de dados são abstrações uwlizadas para organizar os dados de forma a propiciar um uso eficiente por parte dos algoritmos. Estruturas de dados mais elementares para organização dos dados que iremos ver no curso: arranjos, listas, pilhas, filas e árvores. Estas estruturas representam os exemplos clássicos de Wpos abstratos de dados (TAD).

6 Terminologia Básica Os elementos de um conjunto serão representados por objetos, que podem conter diversos atributos. Em algumas situações, assumiremos que um desses atributos possui um papel especial: iden<ficar o objeto chave (key). A chave, em geral, irá pertencer a um conjunto totalmente ordenado: números reais strings (ordem lexicográfica). Essa noção de ordem total é importante pois nos permite definir o menor e maior elementos de um conjunto, o próximo elemento maior que um dado elemento do conjunto. Os objetos podem conter também alguns atributos especiais, uwlizados exclusivamente pelas estruturas de dados.

7 Arranjos (arrays) Um arranjo representa uma quanwdade fixa de elementos de dados que são armazenados de forma conbgua na memória e são acessíveis através de índices.

8 Vetores: são arranjos unidimensionais. Matrizes: são arranjos bidimensionais.

9 Arranjos em Linguagens de Programação Arranjos EstáWcos: Suportados por Wpos primiwvos da linguagem de programação. Este Wpo de arranjo possui um tamanho fixo em tempo de compilação, ou seja, precisamos adivinhar o tamanho do arranjo que precisaremos usar em tempo de compilação. Em C e C++, temos a condição de criar vetores e matrizes mulwdimensionais com essas caracteríswcas. int primos[3] = { 2, 3, 5 }; primos double valores[2][3] = { { 8, 5, 3 }, { 1, 7, 6 } }; valores

10 Arranjos em Linguagens de Programação Arranjos Dinâmicos: Este Wpo de arranjo possui um tamanho fixo, mas que pode ser definido em tempo de execução. Suportados com o uso de funções ou operadores da linguagem capazes de alocar blocos de memória em tempo de execução: Em C temos a família de funções: malloc, calloc, realloc e free. Em C++, temos os operadores new, new[], delete e delete[]. Algumas linguagens oferecem estruturas para representação de matrizes dinâmicas, isto é, uma matriz cuja as dimensões podem ser especificadas em tempo de execução. Já estudamos como funciona a alocação dinâmica de memória em C.

11 Arranjos em Linguagens de Programação Arranjos Dinâmicos: Este Wpo de arranjo possui um tamanho fixo, mas que pode ser definido em tempo de execução. Suportados com o uso de funções ou operadores da linguagem capazes de alocar blocos de memória em tempo de execução: Em C temos a família de funções: malloc, calloc, realloc e free. Em C++, temos os operadores new, new[], delete e delete[]. Algumas linguagens oferecem estruturas para representação de matrizes dinâmicas, isto é, uma matriz cuja as dimensões podem ser especificadas em tempo de execução. Como funciona a alocação dinâmica de memória em C++?

12 Propriedades dos Arranjos Um vetor possui uma organização sequencial implícita, isto é, através da posição que cada elemento ocupa. O i-ésimo elemento de um vetor V, pode ser acessado através da seguinte notação: V[i]. A grande importância da estrutura de dados arranjo é que ela tem uma correspondência com a memória do computador: o código de máquina gerado por um compilador a parwr de um programa em linguagem de alto nível para acesso aos itens é eficiente. comentar exercício E-5.1.

13 Listas (Lists)

14 Listas Uma lista pode ser usada para organizar um conjunto de elementos sequencialmente. elemento Item de dado L I S T A ligações

15 Formas do Encadeamento Encadeamento simples: L I S T A cabeça cauda Encadeamento duplo: L I S T A cabeça cauda

16 TAD Lista: Operações Usuais Um TAD lista pode ser definido através das seguintes operações: ü search(l, k): procura o primeiro elemento com chave k na lista L. ü insert(l, x): insere o elemento x no início da lista L. ü erase(l, x): remove o elemento x da lista L e apaga o item x.

17 TAD Lista: Operações Usuais Outras operações possíveis: ü splice(l 1, L 2 ): emenda os elementos da lista L 2 ao final da lista L 1. ü split(l, x): parte a lista L em duas listas, uma terminando no elemento x e outra começando no elemento x. ü merge(l 1, L 2 ): junta duas listas ordenadas em uma só, também ordenada.

18 TAD Lista: Operações Usuais Outras operações possíveis: ü pred(l, x): retorna o elemento da Lista L que precede o elemento x. ü succ(l, x): retorna o elemento da Lista L que sucede o elemento x.

19 Lista x Vetor Qual a diferença entre uma lista e um vetor?

20 Vantagens x Desvantagens Quais são as vantagens e desvantagens deste Wpo de representação?

21 Lista Encadeada Simples (slist) L I S T A cabeça cauda

22 Lista Encadeada Simples (slist) Implementação por meio de ponteiros. L I S T A cabeça cauda Quais seriam as operações usuais sobre este Wpo de lista?

23 Lista Encadeada Simples (slist) Operações: slist(): construtor de lista vazia. ~slist(): o destrutor da lista irá apagar todos os seus elementos. push_front(v): insere o valor v no início da lista. front(): acessa o primeiro elemento da lista.

24 Lista Encadeada Simples (slist) Operações: insert_after(pos, v): insere o valor v na lista, após o elemento que ocupa a posição pos. erase_after(pos): remove o elemento após o elemento que ocupa a posição pos. find(v): retorna o elemento que contém o valor informado, ou nulo caso não exista um elemento.

25 Lista Encadeada Simples (slist) Operações: clear(): apaga todos os elementos da lista. empty(): retorna verdadeiro se a lista eswver vazia, caso contrário, retorna falso.

26 Obs.: Para não nos complicarmos com os templates por hora, vamos implementar uma lista encadeada simples com números inteiros. Atenção: Uma versão uwlizando templates pode ser encontrada no site do curso: hlp:// estruturas_dados

27 TAD slist: representação interna Cada elemento da lista será representado pela seguinte estrutura: struct item { }; int data; item* next; data 9 next ponteiro p/ próximo item da lista

28 TAD slist: representação interna Por sua vez, a lista será representada por uma classe com um único membro de dados privado: class slist {... private: }; item* head_; head_: ponteiro para a cabeça da lista.

29 TAD slist: definição class slist { public: Estrutura aninhada struct item { int data; item* next; };... };

30 class slist { public: TAD slist: definição... Construtor slist(); ~slist();... Destrutor };

31 class slist { public:... TAD slist: definição void push_front(int v); item* front() const;... };

32 class slist { public:... TAD slist: definição item* insert_after(item* pos, int v); void erase_after(item* pos); item* find(int value) const;... };

33 class slist { public:... void clear(); TAD slist: definição bool empty() const;... };

34 TAD slist: definição class slist {... Tornando estes dois operadores privados, sem fornecer uma implementação, fará com que os objetos slist não possam ser copiáveis private: slist(slist&); slist& operator=(slist&); private: }; item* head_; C++ é uma linguagem onde o idioma de cópia é algo natural, no entanto, demanda extrema atenção do projewsta de uma classe. Você sabe como funciona esse sistema de cópia?

35 Usando o TAD slist slist l; // cria uma lista vazia l.push_front(2); 2 l.push_front(7); 7 2 l.push_front(3); l.push_front(5); l.push_front(9);

36 Usando o TAD slist slist::item* x = l.find(7); head_ if(x) l.erase_after(x); x head_ x

37 x = l.find(5); Usando o TAD slist head_ if(x) x = l.insert_after(x, 8); x head_ x

38 TAD slist: implementação slist(): construtor de lista vazia. slist::slist() : head_(nullptr) { } head_ 0x bits

39 TAD slist: implementação ~slist(): o destrutor da lista irá apagar todos os seus elementos. slist::~slist() { clear(); } head_ head_

40 TAD slist: implementação push_front(int v): insere um elemento no início da lista. void slist::push_front(int v) { head_ = new item{v, head_}; } Lista l contendo 1 elemento l.push_front(7); 7 new item{v, head_}; head_ 2 novo elemento 2 head_ 7 2 head_ = new item{v, head_};

41 TAD slist: implementação front(): acessa o primeiro elemento da lista. slist::item* slist::front() const { return head_; } head_ 7 2

42 TAD slist: implementação insert_after(pos, v): insere um elemento na lista logo após outro elemento. slist::item* slist::insert_after(item* pos, int v) { assert(pos); item* nn = new item {v, pos->next}; pos->next = nn; } return nn;

43 TAD slist: implementação erase_after(item* pos): remove um elemento após o elemento informado. void slist::erase_after(item* pos) { assert(pos && pos->next); item* dn = pos->next; pos->next = dn->next; } delete dn;

44 TAD slist: implementação find(v): retorna o elemento que contém o valor informado, ou nulo caso não exista um elemento. slist::item* slist::find(int v) const { item* i = head_; x = l.find(5); while(i) { head_ 9 if(i->data == v) break; i } } i = i->next; return i; head_ 9 i 5 3 7

45 TAD slist: implementação clear(): apaga todos os elementos da lista. void slist::clear() { while(item* i = head_) { head_ = head_->next; } } delete i;

46 l.clear(); TAD slist: implementação head_ clear(): apaga todos os elementos da lista. i void slist::clear() { while(item* i = head_) { head_ = head_->next; } } delete i; i i i 5 head_ 3 7 head_ 3 7 head_ 3 7 i head_

47 TAD slist: implementação empty(): diz se a lista encontra-se ou não vazia. bool slist::empty() const { return head_ == nullptr; }

48 Qual o espaço de armazenamento da nossa estrutura slist para uma lista contendo n elementos? sizeof(t) = k e sizeof(t*) = v f(n) = n * (k + v) + v supondo k == v, f(n) = k(2n + 1) O(n)

49 Qual a complexidade da operação push_front(v)? O(1)

50 Qual a complexidade da operação front(v)? O(1)

51 Qual a complexidade da operação insert_after(pos, v)? O(1)

52 Qual a complexidade da operação erase_after(pos)? O(1)

53 Qual a complexidade da operação find(v)? O(n)

54 Qual seria a complexidade de uma operação count() que retornasse o número de elementos da lista? Quais estratégia poderíamos uwlizar para implementar esta operação?

55 Se manwvéssemos um ponteiro extra para a cauda da lista, quais outras operações poderíamos ter? Qual o custo delas? push_back?, back?, pop_back?

56 Uma lista encadeada simples nos permite realizar de forma eficiente uma travessia sequencial unidirecional. Quando precisamos de uma estrutura dinâmica que possibilite a travessia bidirecional, uwlizamos listas duplamente encadeadas.

57 Lista Duplamente Encadeada (list) L I S T A cabeça cauda

58 Lista Duplamente Encadeada (list) Implementação por meio de ponteiros. L I S T A cabeça cauda Quais seriam as operações usuais sobre este Wpo de lista?

59 Lista Duplamente Encadeada (list) Operações: list(): construtor de lista vazia. ~list(): o destrutor da lista irá apagar todos os seus elementos. push_front(v): insere o valor v no início da lista. front(): acessa o primeiro elemento da lista.

60 Lista Duplamente Encadeada (list) Operações: next(x): retorna o próximo elemento da lista. previous(x): retorna o elemento anterior ao elemento x na lista. insert(pos, v): insere o valor v na lista, antes do elemento que ocupa a posição pos. erase(x): remove o elemento x.

61 Lista Duplamente Encadeada (list) Operações: find(v): retorna o elemento que contém o valor informado, ou nulo caso não exista um elemento. clear(): apaga todos os elementos da lista. empty(): retorna verdadeiro se a lista eswver vazia, caso contrário, retorna falso.

62 Obs.: Para não nos complicarmos com os templates por hora, vamos implementar uma lista duplamente encadeada para números inteiros. Atenção: Uma versão uwlizando templates pode ser encontrada no site do curso: hlp:// estruturas_dados

63 TAD list: representação interna Cada elemento da lista será representado pela seguinte estrutura: struct item { item* next; item* prev; int data; }; data 9 ponteiro p/ o item anterior ponteiro p/ próximo item da lista

64 TAD list: representação interna Por sua vez, a lista será representada por uma classe com um único membro de dados privado: class list {... private: }; item* head_; head_: ponteiro para a cabeça da lista.

65 TAD list: definição class list { public: Estrutura aninhada }; struct item { item* next; item* prev; int data; };...

66 TAD list: definição class list { public:... Construtor list(); ~list();... Destrutor };

67 TAD list: definição class list { public:... item* next(item* x) const; item* previous(item* x) const;... };

68 TAD list: definição class list { public:... void push_front(int v); item* front() const;... };

69 TAD list: definição class list { public:... item* insert(item* pos, int v); void erase(item* x); item* find(int value) const;... };

70 TAD list: definição class list { public:... void clear(); bool empty() const;... };

71 TAD list: definição class list {... Tornando estes dois operadores privados, sem fornecer uma implementação, fará com que os objetos list não possam ser copiáveis private: list(list&); list& operator=(list&); private: }; item* head_;

72 Usando o TAD list list l; // cria uma lista vazia l.push_front(2); l.push_front(7); l.push_front(3); l.push_front(5); l.push_front(9);

73 Usando o TAD list list::item* x = l.find(7); if(x) l.erase(x);

74 x = l.find(5); Usando o TAD list if(x) x = l.insert(x, 8);

75 TAD list: implementação list(): construtor de lista vazia. list::list() : head_(nullptr) { }

76 TAD list: implementação ~list(): o destrutor da lista irá apagar todos os seus elementos. list::~list() { clear(); }

77 TAD list: implementação next(item* x): retorna o elemento seguinte ao elemento x na lista. list::item* list::next(item* x) const { return x->next; }

78 TAD list: implementação previous(item* x): retorna o elemento anterior ao elemento x na lista. list::item* list::previous(item* x) const { return x->prev; }

79 TAD list: implementação push_front(int v): insere um elemento no início da lista. void list::push_front(int v) { item* nn = new item{head_, nullptr, v}; if(head_) head_->prev = nn; } head_ = nn;

80 TAD list: implementação front(): acessa o primeiro elemento da lista. list::item* list::front() const { return head_; }

81 TAD list: implementação insert(item* pos, int v): insere um elemento na lista antes de outro elemento. list::item* list::insert(item* pos, int v) { assert(pos); item* nn = new item {pos, pos->prev, v}; pos->prev = nn; if(nn->prev) nn->prev->next = nn; else head_ = nn; } return nn;

82 TAD list: implementação erase(item* x): remove o elemento informado. Void list::erase(item* x) { assert(x); if(x->prev) x->prev->next = x->next; else head_ = x->next; if(x->next) x->next->prev = x->prev; } delete x;

83 TAD list: implementação find(v): retorna o elemento que contém o valor informado, ou nulo caso não exista um elemento. list::item* list::find(int v) const { item* i = head_; while(i) { if(i->data == v) break; } i = i->next; } return i;

84 TAD list: implementação clear(): apaga todos os elementos da lista. Void list::clear() { while(item* i = head_) { head_ = head_->next; } } delete i;

85 TAD list: implementação empty(): diz se a lista encontra-se ou não vazia. bool list::empty() const { return head_ == nullptr; }

86 Qual o espaço de armazenamento da nossa estrutura list para uma lista com n elementos? sizeof(t) = k e sizeof(t*) = v f(n) = n * (k + 2v) + v supondo k == v, f(n) = k(3n + 1) O(n)

87 Listas: Considerações Finais

88 Ordem dos Elementos Se os elementos da lista encontram-se ordenados, a ordem linear da lista corresponde à ordem da chave do elemento de dados: O menor elemento corresponde ao elemento da cabeça da lista. O maior elemento corresponde ao elemento da cauda.

89 Travessia Bidirecional Acrescentando um ponteiro para a cauda da lista (tail_), numa lista duplamente encadeadas, poderíamos: realizar uma travessia por qualquer uma das extremidades da lista Acrescentar operações para inserção e remoção ao final da lista.

90 Listas Circulares Listas Encadeada Simples: Podemos adotar a convenção de que a ligação (ponteiro) do úlwmo nó aponte para o primeiro nó da lista head_ Listas Duplamente Encadeadas: A ligação para o próximo nó do úlwmo elemento aponta para o primeiro; e a ligação do elemento anterior no caso do primeiro elemento aponta para o úlwmo. head_ tail_

91 Outras Estratégias de Implementação Elemento SenWnela: Podemos uwlizar alguns objetos especiais, conhecidos como dummy ou sen.nelas, para facilitar a implementação das listas. Neste caso criamos um elemento extra que pode simplificar a escrita das operações. Devemos uwlizar este recurso com bastante cuidado pois em uma aplicação com um grande número de pequenas listas esse espaço extra pode penalizar o sistema.

92 Outras Estratégias de Implementação Implementação de listas por meio de arranjos: Implementação por meio de vetores paralelos.

93 Implementação: vetores paralelos items next Primeiro Item: items[next[head]] Segundo Item: items[next[next[head]]] spare: marcador do próximo espaço vago. dummy: marcador especial do final da lista head 0 dummy 1 spare 6 cabeça cauda

94 Você já pensou num bom uso para a abstração de listas por meio de arranjos? free list Alocação Dinâmica de Memória

95 Listas em Linguagens de Programação Em algumas linguagens de programação esta estrutura de dados é um Wpo primiwvo da linguagem: Lisp, Python, Haskell. Em C++, temos esta estrutura por meio da biblioteca STL, escrita com o próprio core da Linguagem C++: std::list, std::forward_list

96 Quizz Qual o resultado da seguinte operação: sizeof(list::item)? Cuidado: alinhamento e padding das estruturas!

97 Pilhas (Stacks) Uma pilha nada mais é do que uma lista onde as inserções, remoções e acessos ocorrem sempre em uma única extremidade.

98 Pilhas: operações Um TAD pilha pode ser definido através das seguintes operações: push: insere um novo item no topo da pilha. pop: remove um item do topo da pilha. top: retorna o elemento no topo da pilha push(p) P push(i) P I A H L I P pop() H L I P

99 Qual a políwca de acesso implementada por uma pilha? Uma pilha implementa uma políwca do Wpo: o úlwmo a entrar será o primeiro a sair last in, first out (LIFO).

100 Quais são os usos da estrutura de dados pilha?

101 A Linguagem Lua e o uso de Pilhas Exemplo.lua c = terralib.coord2d:new(1.0, 2.0) x = c:getx() void lua_pop (lua_state *L, int n): pops n elements from the stack. Ligação Lua<->C++: coord2d.cpp void lua_pushnumber (lua_state *L, lua_number n): pushes a float with value n onto the stack. static int Coord2D_getX(lua_State* L) { te::gm::coord2d* c = *(te::gm::coord2d**)lua_touserdata(l, 1); lua_pushnumber(l, c->x); return 1; }

102 Como podemos implementar uma estrutura de dados pilha? Vetores Apontadores

103 Pilha: implementação por meio de vetor Esta implementação demanda: Um vetor para os itens. Marcador do topo da pilha Número Máximo de Itens topo 5 tamanho 6 itens 6 5 A 4 H 3 L 2 I 1 P

104 Discussão Aula 31/03/2015 stack.hpp: implementação de pilhas em C/C++ através de vetores.

105 Pilhas: implementação por meio de apontadores topo item próximo A Atenção: esta representação está usando um elemento senwnela ou dummy ou nil. T S I L

106 Qual a complexidade das operações sobre uma pilha? push: insere um novo item no topo da pilha. O(1) pop: remove um item do topo da pilha. O(1) top: retorna o elemento no topo da pilha. O(1)

107 Filas (Queues) Uma fila nada mais é do que uma lista onde as inserções são feitas numa extremidade e as remoções ocorrem na outra extremidade.

108 Filas: operações Um TAD fila pode ser definido através das seguintes operações: enqueue: enfileira um novo item. dequeue: remove um item do início da fila. first: retorna o primeiro elemento da fila A L A enqueue(f) F I enqueue(i) F I F L dequeue() I

109 Qual a políwca de acesso implementada por uma fila? Uma fila implementa uma políwca em que o elemento a ser removido é sempre aquele que entrou primeiro, ou seja, o primeiro a entrar será o primeiro a sair first in, first out (FIFO). => ordem de chegada!

110 Quais são os usos da estrutura de dados fila?

111 Como podemos implementar uma estrutura de dados fila? Vetores x Apontadores

112 Filas: implementação por meio de arranjos Esta implementação demanda três variáveis: Um vetor para os itens. Um marcador do incio da fila e outro do final. Invariantes: head_ == tail_ => fila vazia head_ == tail_ + 1 => fila cheia Obs.: Nossa fila será circular! head_ 0 tail_ 4 size_ 6 q_ F I L A

113 Filas: implementação por meio de arranjos Qual o couidado especial que devemos ter para diswnguir fila cheia de fila vazia? Invariantes: head_ == tail_ => fila vazia head_ == tail_ + 1 => fila cheia Obs.: Nossa fila será circular! head_ 0 tail_ 4 size_ 6 q_ F I L A

114 Operação: Enfileira void queue::enqueue(char c) { std::size_t pos = (tail_ + 1) % size; if(pos == head_) throw std::logic_error("queue overflow!"); q_[tail_] = c; } tail_ = pos;

115 Operação: Desenfileira char queue::dequeue() { if(head_ == tail_) throw std::logic_error("queue underflow!"); char c = q_[head_]; head_ = (head_ + 1) % size; } return c;

116 Filas: implementação por meio de arranjos head_ 0 tail_ enqueue('g') head_ 0 tail_ G enqueue('i') head_ 0 tail_ G I

117 Filas: implementação por meio de arranjos head_ 0 tail_ G I enqueue('l') head_ 0 tail_ G I L enqueue('b') head_ 0 tail_ G I L B

118 Filas: implementação por meio de arranjos head_ 0 tail_ G I L B enqueue('e') head_ 0 tail_ G I L B E enqueue('r') (tail_ + 1) % size_ == head_ => Fila Cheia! Obs.: Nossa fila terá no máximo n - 1 elementos!

119 Filas: implementação por meio de arranjos head_ 0 tail_ dequeue() head_ == tail_ => Fila Vazia!

120 Filas: implementação por meio de arranjos head_ 0 tail_ G I L B E dequeue() head_ 1 tail_ G I L B E dequeue() head_ 2 tail_ G I L B E

121 Filas: implementação por meio de arranjos head_ 2 tail_ G I L B E dequeue() head_ 3 tail_ G I L B E dequeue head_ 4 tail_ G I L B E

122 Filas: implementação por meio de arranjos head_ 4 tail_ G I L B E dequeue() head_ 5 tail_ G I L B E dequeue head_ == tail_ => Fila Vazia!

123 Filas: implementação por meio de arranjos head_ 4 tail_ G I L B E enqueue('r') head_ 4 tail_ G I L B E R enqueue('t') head_ 4 tail_ T I L B E R

124 Discussão queue.hpp: implementação de filas em C++ através de vetores.

125 Filas: implementação por meio de apontadores head item próximo F I tail L L

126 Discussão lqueue.hpp: implementação de filas em C++ através de apontadores.

127 Qual a complexidade das operações sobre uma fila? enqueue: enfileira. O(1) dequeue: desenfileira. O(1) first: retorna o elemento do início da fila. O(1)

128 Considerações Finais

129 Considerações Finais As estruturas vistas nesta aula possuem ampla aplicação na Ciência da Computação. DiscuWremos diversos algoritmos nas próximas aulas que precisarão do apoio dessas estruturas. Também iremos aprofundar nas estruturas de dados de árvores. O projeto da biblioteca STL de C++ é um dos melhores exemplos do uso de técnicas de programação e paradigmas para desenvolvimento de estruturas de dados genéricas eficientes.

130 Considerações Finais Alexander Stepanov Meng Lee David Musser ProjeWstas e Desenvolvedores da biblioteca C++ Standard Template Library (STL)

131 Referências Bibliográficas

132 Referências Bibliográficas CORMEN, T.H.; LIESERSON, C.E.; RIVEST, R.L.; STEIN, C. Introduc<on to Algorithms. 2ª Edição. Mit Press, HOROWITZ, E.; SAHNI, S.; RAJASEKARAN, S. Computer Algorithms. 1ª Edição. Computer Science Press, p. ZIVIANI, N. Projeto de Algoritmos: com implementações em PASCAL e C. 2ª Edição. Editora Thomson, p.

133 Referências Bibliográficas IERUSALIMSCHY, R.; FIGUEIREDO, L. H.; CELES, W. Passing a Language through the Eye of a Needle. ACM Queue, v. 9, n. 5, maio, pp , RAYMOND, E. S. The Lost Art of C Structure Packing. Online. Disponível em: <hlp:// Acesso: 12 de Abril de SAKS, D. Padding and Rearranging Structure Members. Dr. Dobb s, 19 set Online. Disponível em: hlp:// Acesso: 12 de Abril de 2016.

134 Referências Bibliográficas Al Stevens Interviews Alex Stepanov. Dr. Dobb's Journal. Online. Disponível em: < hlp:// Acesso: 12 de Abril de 2016.

135 Exercícios

136 Exercícios E-5.1. Em C e C++ existe alguma diferença práwca em usar laços que processem uma matriz pelas linhas ou pelas colunas? E-5.2. Se estendermos a pergunta do exercício E-5.1 aos compiladores Fortran, qual seria a resposta?

137 Exercícios E-5.3. ParWndo da implementação de listas encadeadas simples (slist), disponível no site do curso, acrescente as seguintes operações: remove(v): remove da lista o primeiro elemento a conter o valor v. Qual a complexidade desta operação? splice_after(pos, L): transfere os elementos da lista L para a lista operada, colocando os elementos de L após a posição pos. A lista L ficará vazia ao final. O tempo desta operação deverá ser O(k), onde k representa o número de elementos da lista L. reverse(): inverte a ordem dos elementos da lista em tempo O(n). Atenção: Existem duas versões da lista encadeada simples: uma para números inteiros e outra para Wpos gerais usando templates. Se você optar pela lista de inteiros, terá que trocar a implementação pelo Wpo char.

138 Exercícios E-5.4. Implemente uma lista duplamente encadeada por meio de apontadores. Esta lista deverá possibilitar: Recuperar o primeiro elemento (front). Recuperar o úlwmo elemento (back). Recuperar o sucessor do elemento x (next). Recuperar o antecessor do elemento x (previous). Inserir na cabeça da lista (push_front). inserir na cauda (push_back). inserir antes de uma posição específica x (insert). Remover um elemento específico (erase). Remover o primeiro elemento (pop_front). Remover o úlwmo elemento (pop_back). Fundir os elementos de uma lista L 2 ao final da lista L 1 (splice). ParWcionar uma lista L em duas listas, uma terminando no elemento x e outra começando no elemento x (split). Reverter os elementos da lista (reverse). Juntar duas listas ordenadas em uma só, também ordenada (merge). Limpar a lista (clear). Dizer se a lista é ou não vazia (empty). Atenção: Existem duas versões da lista duplamente encadeada: uma para números inteiros e outra para Wpos gerais usando templates. Nenhuma delas suporta todas essas operações.

139 Exercícios E-5.5. UWlizar o TAD Pilha para implementar uma calculadora aritméwca com notação polonesa. Você deverá ler uma expressão na forma de string com a notação infixa e transformá-la em uma string com a notação pós-fixa. A parwr da notação pós-fixa, use uma pilha para te ajudar a implementar a avaliação da expressão. Considere apenas as operações aritméwcas básicas. Ex: Entrada: 5 * (((9 + 8) * (4 * 6)) + 7) Transformação: * * 7 + *

140 Exercícios Especiais A entrega não é obrigatória!

141 Exercícios Especiais E-5.6. Uma pilha permite inserir e remover elementos apenas numa extremidade (topo da pilha). Uma fila permite inserir em uma extremidade (cauda) e remover da outra (cabeça). Projete e implemente um deque (double-ended queue) por meio de arranjos, de forma a permiwr inserções e remoções nas duas extremidas. As quatro operações para inserir e remover elementos dos dois lados do deque devem ter complexidade O(1).

142 Exercícios Especiais E-5.7. Projete um alocador de memória em C uwlizando listas de espaço vazio. Sua API deve ser formada pelas seguintes funções: void *my_malloc(unsigned nbytes): Aloca um bloco de nbytes e retorna um ponteiro para o início do bloco; void my_free(void *ap): Libera um bloco de memória. void print_available_mem(): Imprime na tela a lista de blocos vazios:

143 Exercícios Especiais E-5.8. Projete um alocador de memória para pequenos objetos em C++. Os blocos de memória gerenciados devem ser de tamanho fixo e compa veis com o tamanho do objeto que uwlizará esse alocador. Dica: além do projeto do alocador, você terá que sobrecarregar os operadores new, new[], delete e delete[] na classe de seus objetos.

144 Fim!