C++, POO, Tipos Abstratos de Dados

Programação e Desenvolvimento de Software 2
Tipos Abstratos de Dados

Prof. Carlos Vinicius
carloslima@dcc.ufmg.br
http://github.com/flaviovdf/programacao-2
Algoritmos e Estruturas de Dados
▝ Algoritmo:
▝ Sequência de passos/ações.
▝ Trabalham em cima das estruturas de dados.
▝ Estrutura de dados:
▝ Abstração de uma situação real.
▝ “Dão suporte” aos algoritmos.
Footer 2
Estruturas de Dados
▝ Dados podem ser representados de diversas formas.
▝ A forma que representamos os dados é guiado pelas
operações que vamos fazer em cima deles.
▝ Quais operações vamos realizar?
▝ Os dados suportam as mesmas?
Footer 3
Como representar uma coleção de objetos?
TADs e Operações
▝ Quais operações uma coleção suporta?
▝ Pense em um conjunto matemático.
Footer 5
TADs e Operações
▝ Quais operações uma coleção suporta?
▝ Pense em um conjunto matemático.
▝ adicionar (união) elemento;
▝ remover (complemento) elemento;
▝ interseção;
▝ número de elementos;
▝ domínio;
▝ ...
Footer 6
Tipos Abstratos de Dados (TADs)
▝ Modelo matemático, acompanhado das operações definidas
sobre o modelo.
▝ Conjunto dos inteiros acompanhado das operações de
adição, subtração e multiplicação.
▝ A implementação do algoritmo em uma linguagem de
programação exige a representação do TAD em termos dos
tipos de dados e dos operadores suportados.
Footer 7
Contrato
▝ TADs são contratos.
▝ Funções que operam em cima da memória.
Footer 8
Encapsulamento
▝ Conceito importante em TADs.
▝ Usuário:
▝ Enxerga apenas a interface.
▝ Não se preocupa, em primeiro momento, como é o TAD
por baixo.
Footer 9
Então TADs são classes?
TADs vs Classes
▝ Não!
▝ TADs são um conceito mais geral.
▝ Existem em qualquer tipo de linguagem.
▝ Em C++
▝ Sim, mapeiam bem para classes.
▝ Ou para interfaces
▝ Assuntos futuro.
▝ Vamos fazer uma abordagem bottom up.
Footer 11
TADs vs Algoritmos
▝ Algoritmo
▝ Sequência de ações executáveis entrada → saída.
▝ Exemplo: “Receita de Bolo”.
▝ Algoritmos usam TADs.
▝ TADs
▝ Contrato
+
▝ Memória.
Footer 12
▝ Podemos considerar TADs como generalizações de tipos
primitivos e procedimentos como generalizações de
operações primitivas.
▝ O TAD encapsula tipos de dados. A definição do tipo e todas
as operações ficam localizadas numa seção do programa.
▝ Os usuários do TAD só tem acesso a algumas operações
disponibilizadas sobre esses dados.
Footer 13
Footer 14
▝ TADs são um conceito de programação.
▝ Vamos aprender como implementar os mesmos usando
classes e objetos.
▝ Outras linguagens
▝ structs + funções ( C ).
▝ traits ( Rust ).
▝ duck typing ( Python, Ruby ).
▝ classes e interfaces ( Java, C++ ).
Footer 15
Listas
Listas Lineares
▝ Sequência de zero ou mais itens.
▝ x1, x2, ··· , xn, na qual xi satisfaz alguma propriedade.
▝ Posições relativas
▝ Assumindo n ≥ 1, x1 é o primeiro item da lista e xn é o
último item da lista.
▝ xi precede xi+1 para i = 1, 2, ···, n – 1.
▝ xi sucede xi-1 para i = 2, 3, ···, n.
▝ xi é dito estar na i-ésima posição da lista.
Footer 17
Lista de números inteiros
▝ Considere uma uma lista de inteiros. Poderíamos definir

TAD Lista, com as seguintes operações:
▝ Faça a lista vazia;
▝ Obtenha o primeiro elemento da lista; se a lista estiver
vazia, então retorna nulo;
▝ Insira um elemento na lista.
Footer 18
Lista de números inteiros
▝ Quais outras operações podem ser definidas?

▝ Retirar o i-ésimo item.
▝ Localizar o i-ésimo item.
▝ Fazer uma cópia da lista linear.
▝ Ordenar os itens da lista em ordem ascendente ou
descendente.
▝ Buscar a ocorrência de um item com um valor particular.
Footer 19
Solução Zero
#ifndef PDS2_LISTA_VETOR_H
#define PDS2_LISTA_VETOR_H
#define TAMANHO 100 Constante no .h. Em C++ também existe o const
class ListaVetorInteiros {
private:
int *_elementos; Vetor de elementos que será alocado dinamicamente (heap)
int _num_elementos_inseridos;
public:
// Construtor
ListaVetorInteiros();
// Destrutor
~ListaVetorInteiros();
// Insere um inteiro na lista
void inserir_elemento(int elemento);
// Imprime a lista
void imprimir();
};
#endif
Footer 20
Como Implementar?
Footer 21
Construtor (e início do .h)
#include <iostream> Em algum momento vamos imprimir a lista.
#include "listavetor.h"
ListaVetorInteiros::ListaVetorInteiros() {
this->_elementos = new int[TAMANHO]();
this->_num_elementos_inseridos = 0;
}
Footer 22
}
Objeto ListaVetorInteiros {
int *_elementos;
}
Footer 23
}
0 1 2 3 4 5 97 98 99
int *_elementos; ? ? ? ? ? ? ... ? ? ?
}
Footer 24
}
0 1 2 3 4 5 97 98 99
int *_elementos; ? ? ? ? ? ? ... ? ? ?
int _num_elementos_inseridos = 0;
}
Footer 25
Adicionando elementos?
Footer 26
void ListaVetorInteiros::inserir_elemento(int elemento) {
if (this->_num_elementos_inseridos == TAMANHO) {
std::cerr << "Erro, lista cheia" << std::endl;
exit(1);
}
this->_elementos[this->_num_elementos_inseridos] = elemento;
this->_num_elementos_inseridos++;
}
0 1 2 3 4 5 97 98 99
int *_elementos; ? ? ? ? ? ? ... ? ? ?
}
Footer 27
exit(1);
}
}
0 1 2 3 4 5 97 98 99
int *_elementos; ? ? ? ? ? ? ... ? ? ?
}
Footer 28
exit(1);
}
}
0 1 2 3 4 5 97 98 99
int *_elementos; 7 ? ? ? ? ? ... ? ? ?
}
Footer 29
exit(1);
}
}
0 1 2 3 4 5 97 98 99
int *_elementos; 7 ? ? ? ? ? ... ? ? ?
}
Footer 30
exit(1);
}
}
0 1 2 3 4 5 97 98 99
int *_elementos; 7 ? ? ? ? ? ... ? ? ?
}
Footer 31
exit(1);
}
}
0 1 2 3 4 5 97 98 99
int *_elementos; 7 ? ? ? ? ? ... ? ? ?
}
Footer 32
exit(1);
}
}
0 1 2 3 4 5 97 98 99
int *_elementos; 7 2 ? ? ? ? ... ? ? ?
}
Footer 33
exit(1);
}
}
0 1 2 3 4 5 97 98 99
int *_elementos; 7 2 ? ? ? ? ... ? ? ?
}
Footer 34
exit(1);
}
}
0 1 2 3 4 5 97 98 99
int *_elementos; 7 2 ? ? ? ? ... ? ? ?
}
Footer 35
exit(1);
}
}
0 1 2 3 4 5 97 98 99
int *_elementos; 7 2 3 ? ? ? ... ? ? ?
}
Footer 36
E por aí vai...
exit(1);
}
}
0 1 2 3 4 5 97 98 99
int *_elementos; 7 2 3 ? ? ? ... ? ? ?
}
Footer 37
Imprimir
▝ Trivial.
void ListaVetorInteiros::imprimir() {
for (int i = 0; i < this->_num_elementos_inseridos; i++)
std::cout << this->_elementos[i] << " ";
std::cout << std::endl;
}
Footer 38
Destrutor
▝ Alocamos um vetor.
▝ Efetuamos um new.
▝ Precisamos de um delete.
▝ Lembrando, cada new → um delete.
ListaVetorInteiros::~ListaVetorInteiros() {
delete[] this->_elementos;
}
Footer 39
Mais de 100 elementos?
Footer 40
Mais de 100 elementos?
Footer 41
#ifndef PDS2_LISTA_VETOR_H
#define PDS2_LISTA_VETOR_H
#define TAMANHO_INICIAL 100 Tamanho inicial que será aumentado
class ListaVetorInteiros {
private:
Solução Melhor
int *_elementos;
int _capacidade; Tamanho atual que também será aumentado
public:
// Construtor
ListaVetorInteiros();
// Destrutor
~ListaVetorInteiros();
// Insere um inteiro na lista
// Imprime a lista
void imprimir();
};
#endif
Footer 42
Construtor
Footer 43
Construtor
this->_elementos = new int[TAMANHO_INICIAL]();
this->_capacidade = TAMANHO_INICIAL;
}
Footer 44
Construtor
this->_elementos = new int[TAMANHO_INICIAL]();
this->_capacidade = TAMANHO_INICIAL;
}
0 1 2 3 4 5 97 98 99
int _elementos; ? ? ? ? ? ? ... ? ? ?
int _capacidade = 100;
}
Footer 45
Métodos que não mudam
▝ Imprime.
▝ Destrutor.
Footer 46
Complicação
▝ Inserir elemento.
▝ Precisamos verificar se a lista está cheia ou não.
Footer 47
Ideia
▝ Inserir elemento.
▝ Caso o vetor fique cheio:
▝ Duplicar o mesmo;
▝ Copiar tudo para o novo;
▝ Aumentar a capacidade.
▝ Estamos implementando o vector
▝ Nome do container na STL.
Footer 48
Inserir elemento
// . . .
}
Footer 49
Passo a Passo
Alocamos tamanho inicial.
Vamos supor que seja igual a 3.
0 1 2
int *_elementos; ? ? ?
}
Footer 50
Passo a Passo
Inserindo um elemento.
0 1 2
int *_elementos; 7 ? ?
}
Footer 51
Passo a Passo
Outro.
0 1 2
int *_elementos; 7 0 ?
}
Footer 52
Passo a Passo
+1.
0 1 2
int *_elementos; 7 0 1
}
Footer 53
Passo a Passo
+ outro?!
0 1 2
}
Footer 54
Passo a Passo
+ Alocamos espaço. int *new_data; ? ? ? ? ? ?
0 1 2
}
if (this->_num_elementos_inseridos == this->_capacidade) {
int *new_data = new int[this->_capacidade * 2];

new_data[i] = this->_elementos[i];
this->_elementos = new_data;
this->_capacidade = this->_capacidade * 2;
}
// . . .
}
Footer 55
Passo a Passo
+ Copiamos os dados. int *new_data; ? ? ? ? ? ?
0 1 2
}

}
// . . .
}
Footer 56
Passo a Passo
+ Copiamos os dados. int *new_data; 7 0 1 ? ? ?
0 1 2
}

}
// . . .
}
Footer 57
Passo a Passo
+ Apagamos os int *new_data; 7 0 1 ? ? ?
dados antigos.
int *_elementos;
}

}
// . . .
}
Footer 58
Passo a Passo
+ Colocamos os novos no local.
int *_elementos;
7 0 1 ? ? ?
}

}
// . . .
}
Footer 59
Passo a Passo
+ Aumentamos a capacidade.
int *_elementos;
int _num_elementos_inseridos = 3; 7 0 1 ? ? ?
}

}
// . . .
}
Footer 60
Passo a Passo
Agora estamos igual a antes.
int *_elementos;
int _num_elementos_inseridos = 3; 7 0 1 ? ? ?
}

// . . .
this->_elementos[this->_num_elementos_inserido] = elemento;
}
Footer 61
Passo a Passo
Agora estamos igual a antes.
int *_elementos;
int _num_elementos_inseridos = 4; 7 0 1 9 ? ?
}

// . . .
this->_elementos[this->_num_elementos_inserido] = elemento;
}
Footer 62
E para remover o último elemento?
▝ Quero uma nova operação no meu TAD.
▝ Atualizar .h
▝ Implementar no .cpp
▝ Remover o último elemento.
Footer 63
void ListaVetorInteiros::remover_ultimo() {
this->_num_elementos_inseridos--;
}
int *_elementos;
int _num_elementos_inseridos = 3; 7 0 1
}
▝ Pode ficar um lixo no fim da fila. Mas ok, se usarmos

n_elementos para iterar não acessamos o mesmo.
Footer 64
}
int *_elementos;
int _num_elementos_inseridos = 3; 7 0 1
}

Footer 65
}
int *_elementos;
int _num_elementos_inseridos = 2; 7 0 ?
}

Footer 66
Removendo o Primeiro Elemento
▝ Podemos copiar a ideia anterior.
▝ Guardar um índice para o início.
▝ Funciona bem?
Footer 67
▝ Chato não desperdiçar memória.
void ListaVetorInteiros::remover_primeiro() {
this->_inicio++;
}
int *_elementos; 7 0 ?
int _inicio = 0;
}
Footer 68
this->_inicio++;
}
int *_elementos; ? 0 ?
int _inicio = 1;
}
Footer 69
this->_inicio++;
}
int *_elementos; ? 0 ?
int _inicio = 1;
}
Footer 70
Remover o n-ésimo elemento?
int _num_elementos = 0;
int *_elementos;
7 0 1 9 ? ?
int _inicio = 0;
}
Footer 71
Remover o n-ésimo elemento?
int _num_elementos = 0;
int *_elementos;
7 0 1 9 ? ?
int _inicio = 0;
}
Footer 72
Listas com Ponteiros
Lista com Ponteiros
▝ Para casos complicados com arrays.
▝ Podemos explorar ponteiros.
Início Fim
elem elem elem elem
prox prox prox nullptr
Footer 74
#ifndef PDS2_NODE_H
#define PDS2_NODE_H
struct node_t {
Struct sem métodos. Representa um elemento
int elemento;
da lista, chamado nó.
node_t *proximo;
};
class ListaSimplesmenteEncadeada {
private:
Cabeçalho
node_t *_inicio; Início e fim da lista.

node_t *_fim;
public:
ListaSimplesmenteEncadeada();
~ListaSimplesmenteEncadeada();
void imprimir();
};
#endif
Footer 75
Iniciamos Assim
struct node_t { ?
int elemento;
node_t *proximo;
};
nullptr!
Footer 76
Ficamos Assim
struct node_t { 7
int elemento;
node_t *proximo;
};
struct node_t {
int elemento; 23
node_t *proximo;
};
struct node_t {
int elemento;
node_t *proximo;
};
Footer 77
Ficamos Assim
struct node_t { 7
int elemento;
node_t *proximo;
};
struct node_t {
int elemento; 23
node_t *proximo;
};
struct node_t {
- Um Struct aponta para outro (campo proximo). int elemento;
- Cada Struct mantém um valor (campo elemento). node_t *proximo;
};
Footer 78
Ficamos Assim
class ListaSimplesmenteEncadeada {
node_t *_inicio;
node_t *_fim;
struct node_t { 7 int _num_elementos_inseridos;
int elemento; };
node_t *proximo;
};
struct node_t {
int elemento; 23
node_t *proximo;
};
struct node_t {
- O objeto (lista) mantém os ponteiros iniciais (campos _inicio e _fim). int elemento;
- Além do número de elementos (campo _num_elementos_inseridos). node_t *proximo;
};
Footer 79
Mais Abstrato
Início Fim
elem elem elem elem
Footer 80
Vamos Implementar?
Footer 81
Construtor
ListaSimplesmenteEncadeada::ListaSimplesmenteEncadeada() {
this->_inicio = nullptr;
this->_fim = nullptr;
}
Footer 82
Construtor
}
Início
nullptr!
Footer 83
Construtor
}
Início Fim
nullptr!
Footer 84
Construtor
}
Início Fim
node_t *inicio = nullptr;
node_t *fim = nullptr;
}
nullptr!
Footer 85
void ListaSimplesmenteEncadeada::inserir_elemento(int elemento) {
node_t *novo = new node_t();
novo->elemento = elemento;
novo->proximo = nullptr;
if (this->_inicio == nullptr) {
this->_inicio = novo;
this->_fim = novo;
} else {
this->_fim->proximo = novo;
Adicionando
this->_fim = novo;
}
}
Início Fim
nullptr!
Footer 86
this->_fim = novo;
} else {
Adicionando
this->_fim = novo;
}
}
Início Fim
nullptr!
??
??
Footer 87
this->_fim = novo;
} else {
Adicionando
this->_fim = novo;
}
}
Início Fim
nullptr!
elem=7
??
Footer 88
this->_fim = novo;
} else {
Adicionando
this->_fim = novo;
}
}
Início Fim
nullptr!
elem=7
nullptr
Footer 89
this->_fim = novo;
} else {
Adicionando
this->_fim = novo;
}
}
Início Fim
nullptr!
elem=7
nullptr
Footer 90
this->_fim = novo;
} else {
Adicionando
this->_fim = novo;
}
}
Início Fim
nullptr!
elem=7
nullptr
Footer 91
this->_fim = novo;
} else {
Adicionando
this->_fim = novo;
}
}
Início Fim
elem=7
nullptr
Footer 92
this->_fim = novo;
} else {
Adicionando
this->_fim = novo;
}
}
Início Fim
elem=7
nullptr
Footer 93
this->_fim = novo;
} else {
Adicionando
this->_fim = novo;
}
}
Início Fim
elem=7
nullptr
Footer 94
this->_fim = novo;
} else {
Adicionando
this->_fim = novo;
}
}
Início Fim
elem=7 elem=2
nullptr nullptr
Footer 95
this->_fim = novo;
} else {
Adicionando
this->_fim = novo;
}
}
Início Fim
elem=7 elem=2
nullptr nullptr
Footer 96
this->_fim = novo;
} else {
Adicionando
this->_fim = novo;
}
}
Início Fim
elem=7 elem=2
*prox nullptr
Footer 97
this->_fim = novo;
} else {
Adicionando
this->_fim = novo;
}
}
Início Fim
elem=7 elem=2
*prox nullptr
Footer 98
this->_fim = novo;
} else {
Adicionando
this->_fim = novo;
}
}
Início Fim
elem=7 elem=2
*prox nullptr
Footer 99
this->_fim = novo;
Redesenhando
} else {
this->_fim = novo;
}
}
Início Fim
elem=7 elem=2
*prox nullptr
Footer 100
this->_fim = novo;
} else {
this->_fim = novo;
}
}
Início Fim
+1
elem=7 elem=2 elem=0
*prox nullptr nullptr

Footer 101
this->_fim = novo;
} else {
this->_fim = novo;
}
}
Início Fim
+1
*prox nullptr nullptr

Footer 102
this->_fim = novo;
} else {
this->_fim = novo;
}
}
Início Fim
+1
*prox *prox nullptr

Footer 103
this->_fim = novo;
} else {
this->_fim = novo;
}
}
Início Fim
+1
*prox *prox nullptr

Footer 104
Qual a ideia?
▝ Criar um novo nó.
▝ Setar o valor (campo elemento).
▝ Atualizar o ponteiro proximo do último nó para o novo.
▝ Atualizar o fim da lista!
Footer 105
Destrutor
anterior próximo
Início Fim
elem elem elem elem elem
prox prox prox prox nullptr
Footer 106
Destrutor
anterior próximo
Início Fim
Footer 107
Destrutor
anterior próximo
Início Fim
Footer 108
Destrutor
anterior próximo
Início Fim
elem elem elem elem
Footer 109
Destrutor
anterior próximo
Início Fim
elem elem elem elem
Footer 110
Destrutor
anterior próximo
Início Fim
elem elem elem elem
Footer 111
Destrutor
próximo
Início Fim
elem elem elem
prox prox nullptr
Footer 112
Destrutor
ListaSimplesmenteEncadeada::~ListaSimplesmenteEncadeada() {
node_t *anterior = nullptr;
node_t *proximo = this->_inicio;
while (proximo != nullptr) {
anterior = proximo;
proximo = proximo->proximo;
delete anterior;
}
}
Início anterior proximo Fim
elem elem elem
prox prox nullptr
Footer 113
Destrutor
anterior = proximo;
delete anterior;
}
}
elem elem elem
prox prox nullptr
Footer 114
Destrutor
anterior = proximo;
delete anterior;
}
}
elem elem elem
prox prox nullptr
Footer 115
Destrutor
anterior = proximo;
delete anterior;
}
}
elem elem elem
prox prox nullptr
Footer 116
Destrutor
anterior = proximo;
delete anterior;
}
}
elem elem
prox nullptr
Footer 117
Destrutor
anterior = proximo;
delete anterior;
}
}
elem elem
prox nullptr
Footer 118
Destrutor
anterior = proximo;
delete anterior;
}
}
elem elem
prox nullptr
Footer 119
Destrutor
anterior = proximo;
delete anterior;
}
}
elem elem
prox nullptr
Footer 120
Destrutor
anterior = proximo;
delete anterior;
}
}
elem
nullptr
Footer 121
Neste momento próximo é null
anterior = proximo;
delete anterior;
}
}
elem
nullptr
Footer 122
Vai terminar o laço
anterior = proximo;
delete anterior;
}
}
elem
nullptr
Footer 123
Vai terminar o laço
anterior = proximo;
delete anterior;
}
}
Footer 124
Fora do laço, ficam os campos sem new
anterior = proximo;
delete anterior;
}
}
Footer 125
Morrem com o objeto.
anterior = proximo;
delete anterior;
}
}
Footer 126
Ideia da aula
▝ Temos duas implementações de um mesmo TAD.
▝ Uma com vetor, outra com ponteiros.
▝ Podemos implementar na lista encadeada
▝ Remover i-ésimo elemento;
▝ Imprimir;
▝ ...
Footer 127
TADs
▝ Os dois TADs listas suportam.
▝ inserção no início/fim.
▝ remoção no início/fim.
▝ imprimir elementos.
▝ Apenas a lista encadeada (ponteiros)
▝ remover o i-ésimo.
▝ seria possível fazer no vetor, mas chato.
Footer 128
Hands on
▝ Remover i-ésimo elemento.
▝ Imprimir.
Footer 129
Futuro . . .
▝ Dois TADs com métodos iguais
▝ Semanticamente
▝ No futuro vamos usar interfaces
▝ Polimorfismo.
▝ Os métodos em comum viram um tipo único.
▝ Podemos usar templates também
▝ Listas de qualquer coisa.
▝ Ver no git.
Footer 130

C++, POO, Tipos Abstratos de Dados

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

C++, POO, Tipos Abstratos de Dados

Загружено:

Авторское право:

Доступные форматы

Programação e Desenvolvimento de Software 2

Tipos Abstratos de Dados

▝ Considere uma uma lista de inteiros. Poderíamos definir

▝ Quais outras operações podem ser definidas?

#include <iostream> Em algum momento vamos imprimir a lista.

#define TAMANHO_INICIAL 100 Tamanho inicial que será aumentado

for (int i = 0; i < this->_num_elementos_inseridos; i++)

for (int i = 0; i < this->_num_elementos_inseridos; i++)

for (int i = 0; i < this->_num_elementos_inseridos; i++)

for (int i = 0; i < this->_num_elementos_inseridos; i++)

for (int i = 0; i < this->_num_elementos_inseridos; i++)

for (int i = 0; i < this->_num_elementos_inseridos; i++)

void ListaVetorInteiros::inserir_elemento(int elemento) {

void ListaVetorInteiros::inserir_elemento(int elemento) {

▝ Pode ficar um lixo no fim da fila. Mas ok, se usarmos

▝ Pode ficar um lixo no fim da fila. Mas ok, se usarmos

▝ Pode ficar um lixo no fim da fila. Mas ok, se usarmos

elem elem elem elem

prox prox prox nullptr

node_t *_inicio; Início e fim da lista.

elem elem elem elem

prox prox prox nullptr

elem=7 elem=2 elem=0

*prox nullptr nullptr

elem=7 elem=2 elem=0

*prox nullptr nullptr

elem=7 elem=2 elem=0

*prox *prox nullptr

elem=7 elem=2 elem=0

*prox *prox nullptr

elem elem elem elem elem

prox prox prox prox nullptr

elem elem elem elem elem

prox prox prox prox nullptr

elem elem elem elem elem

prox prox prox prox nullptr

elem elem elem elem

prox prox prox nullptr

elem elem elem elem

prox prox prox nullptr

elem elem elem elem

prox prox prox nullptr

elem elem elem

prox prox nullptr

Início anterior proximo Fim

elem elem elem

prox prox nullptr

Início anterior proximo Fim

elem elem elem

prox prox nullptr

Início anterior proximo Fim

elem elem elem

prox prox nullptr

Início anterior proximo Fim

elem elem elem

prox prox nullptr

Início anterior proximo Fim

Início anterior proximo Fim

Início anterior proximo Fim

Início anterior proximo Fim

Início anterior proximo Fim

Início anterior proximo Fim

Início anterior proximo Fim

prox prox nullptr

prox prox nullptr