Tipos Abstratos de Dados, Vistas e Ordenação
Igor Machado Coelho
15/11/2026
São requisitos para essa aula o conhecimento de:
struct) com métodos, e ponteiros (aula
de Introdução)Na Introdução, criamos agregados com struct e métodos, e
vimos deduções de tipos primitivos em C ou C++ com auto.
Nesta aula, veremos que:
concept)
descrevem um TAD diretamente no código (ou Protocol em
Python)Importante: na Introdução, vimos que em C++ é
possível incluir rotinas dentro de agregados (struct), que
automaticamente são organizados como ponteiros de função. Em C puro isso
precisa ser feito manualmente, ou usar funções livres globais. Nesse
curso, sempre que possível evitaremos ponteiros!
Um Tipo Abstrato de Dados (TAD), do inglês Abstract Data Type – ADT, é composto por:
struct)cria() e libera(), para inicializar os dados e
finalizar a memória corretamente.cria()Exemplo cotidiano: você usa um elevador apertando botões (operações), confiando que ele não abre a porta entre andares (invariante). Não precisa saber como é o motor!
Um número racional é uma fração ba, com a,b inteiros e b=0.
Operações do TAD Racional:
soma(r): devolve um novo racional, com
ba+dc=bdad+cbmultiplica(r): devolve um novo
racional, com
ba⋅dc=bdacigual(r): verdadeiro se representam o mesmo
número (note que
21=42)imprime(): imprime na forma reduzida/canônica, como
1/2Além disso, um método cria(n, d) inicializa o racional
dn
(pré-condição:
d=0)
Desafio: 21 e 42 são o mesmo racional? E o mesmo agregado?
O modelo de dados é simples (int num, den;), mas
onde reduzir a fração é uma decisão de
implementação!
Para reduzir ba, dividimos ambos por mdc(a,b). O algoritmo de Euclides usa mdc(a,b)=mdc(b,amodb):
Custo: depende do tamanho dos números a e b, não entraremos em detalhes agora! É barato, mas não é O(1)!
Ideia: reduzir sempre, em
cria. Como soma e multiplica
criam seus resultados com cria, todo racional fica
reduzido.
struct Racional1 {
int num, den; // inv: den > 0, mdc(num,den) == 1
void cria(int n, int d) { // pre: d != 0
int g = mdc(n, d);
if (d < 0) g = -g; // sinal no numerador
num = n / g;
den = d / g;
}
void imprime() { ... }
Racional1 soma(Racional1 r) { ... }
Racional1 multiplica(Racional1 r) { ... }
bool igual(Racional1 r) { ... }
};Ideia: reduzir sempre, em
cria. Como soma e multiplica
criam seus resultados com cria, todo racional fica
reduzido.
struct Racional1 {
// ...
void imprime() { println("{}/{}", num, den); }
Racional1 soma(Racional1 r) {
Racional1 s;
s.cria(num * r.den + r.num * den, den * r.den);
return s;
}
Racional1 multiplica(Racional1 r) {
Racional1 m;
m.cria(num * r.num, den * r.den);
return m;
}
bool igual(Racional1 r) { return num == r.num && den == r.den; }
};Invariante forte: existe uma única representação para cada número (forma canônica).
Por isso, igual é só comparar campos, e
imprime não precisa reduzir.
Em troca, toda criação paga um mdc.
Ideia: nunca reduzir nas operações aritméticas. Só reduzimos quando for inevitável (na impressão).
Ideia: nunca reduzir nas operações aritméticas. Só reduzimos quando for inevitável (na impressão).
struct Racional2 {
// ...
void imprime() {
int g = mdc(num, den);
if (den < 0) g = -g;
println("{}/{}", num / g, den / g);
}
Racional2 soma(Racional2 r) {
return {num * r.den + r.num * den, den * r.den};
}
Racional2 multiplica(Racional2 r) {
return {num * r.num, den * r.den};
}
bool igual(Racional2 r) { return num * r.den == r.num * den; }
};Invariante fraca: 21 e 42 convivem como agregados diferentes.
Por isso, igual não pode comparar campos: usa
ad=cb.
Em troca, cria, soma e
multiplica ficam sem nenhum
mdc.
O código cliente é idêntico para as duas implementações:
Na memória, porém, os agregados são diferentes:
Racional1 b: | num: 1 | den: 2 | (reduzido em cria)
Racional2 b: | num: 2 | den: 4 | (guardado como veio)
Observação: o TAD Racional não carrega recursos
dinâmicos, então não precisa de libera()! Todo TAD
com função libera() significará
não-copiável como convenção nesse curso, ou seja, sem
operator= válido. Assim, o Racional é
copiável.
C/C++ permite definir conceitos (ou concepts). Esse
recurso permite definições genéricas sobre algum tipo,
exigindo, por exemplo, que um agregado possua certos métodos. Exemplo
prático para o TAD Racional (não incluímos o cria() e
libera()):
template <typename R>
concept RacionalTAD = requires(R a, R b) {
{ a.soma(b) } -> std::same_as<R>; // devolve outro R
{ a.multiplica(b) } -> std::same_as<R>;
{ a.igual(b) } -> std::same_as<bool>;
{ a.imprime() };
};O requires lista expressões que
precisam compilar, e a seta -> restringe o tipo do
resultado.
Uma forma de validação de tipos em tempo de compilação é o
static_assert. Como garantir que as duas implementações
satisfazem o TAD?
static_assert(RacionalTAD<Racional1>);
static_assert(RacionalTAD<Racional2>);
// static_assert(RacionalTAD<int>); // ERRO: int não tem 'soma'Também podemos usar um conceito no lugar de um tipo automático,
restringindo o auto:
Com o conceito, escrevemos o algoritmo uma vez, para qualquer implementação. Exemplo: a potência rk=r⋅r⋯r (k vezes).
Desafio: aumente k. Qual das duas versões imprime um valor errado primeiro? Por quê?
O conceito verifica quais operações existem e com que tipos, mas não verifica o contrato:
struct RacionalErrado {
int num, den;
void cria(int n, int d) { num = n; den = d; }
RacionalErrado soma(RacionalErrado r) { // subtrai!
return {num * r.den - r.num * den, den * r.den};
}
RacionalErrado multiplica(RacionalErrado r) { return r; }
bool igual(RacionalErrado r) { return true; }
void imprime() { println("?"); }
};
static_assert(RacionalTAD<RacionalErrado>); // passa!Nenhum static_assert percebe que soma
subtrai, ou que igual mente. Para a
semântica, usamos testes e
contratos (pre e post).
O mesmo TAD, duas implementações, custos distribuídos de forma diferente (L: número de dígitos dos valores envolvidos):
| operação | Racional1 (canônica) | Racional2 (preguiçosa) |
|---|---|---|
cria |
O(L)
(um mdc) |
O(1) |
soma |
O(L) | O(1) |
multiplica |
O(L) | O(1) |
igual |
O(1) | O(1) (produto cruzado) |
imprime |
O(1) | O(L)
(um mdc) |
tamanho de num, den |
mínimo possível | cresce a cada operação |
Um modelo de custos é a tabela com o custo de cada operação de uma implementação. Nenhuma linha sozinha diz qual implementação é melhor: é um balanço.
Pergunta: se um programa faz milhões de somas e só imprime o resultado no fim, qual você escolheria? E se compara racionais o tempo todo?
No modelo RAM (aula de Introdução), uma operação aritmética custa um passo porque o dado tem tamanho fixo. A Racional2 viola essa hipótese silenciosamente:
(2/4)^k com Racional2 (sem reduzir): num = 2^k, den = 4^k = 2^(2k)
(2/4)^k com Racional1 (reduzindo): num = 1, den = 2^k
int de 32 bits (ou int32_t),
416=232
já não cabe (overflow): a Racional2 erra em
k=16igual faz produtos cruzados
(ad
e
cb),
que estouram ainda antesmdc “compra”Importante: o modelo de custos precisa incluir o que a implementação faz com os dados, e não só quantos passos executa. Uma operação O(1) que produz resultado errado não é rápida, é apenas errada.
Desafio: para resolver isso, implemente um BigNum (números gigantes ilimitados em vetores).
Para escrever um algoritmo sobre um vetor, em C passamos ponteiro e tamanho separados:
int soma(int* v, int n); // e se alguém passar o 'n' errado?
soma(a + 2, 3); // aritmética de ponteiros exposta ao clienteO ponteiro e o tamanho só fazem sentido juntos. Isso pede um TAD!
Queremos um agregado leve que:
iEsse tipo de TAD é chamado de Vista (do inglês View).
Importante: como boa prática de programação, evitaremos a passagem de ponteiros em parâmetros de funções.
SpanIntUm SpanInt representa um trecho de vetor de
int (sem posse), com os métodos tamanho(),
le(i), altera(i, v) e
fatia(a, b), que retorna outro SpanInt com os
elementos de a até b-1 (como o slice
v[a:b] em Python).
struct SpanInt {
int* inicio; // primeiro elemento
int n; // número de elementos
int tamanho() { return n; }
int le(int i) { return inicio[i]; }
void altera(int i, int v) { inicio[i] = v; }
// pre: 0 <= a <= b <= n
SpanInt fatia(int a, int b) {
return {.inicio = inicio + a, .n = b - a};
}
}; // le e altera: pre(0 <= i < n)Importante: a aritmética de ponteiros
(inicio + a) fica escondida dentro do
TAD.
Uma Vista (do inglês View) é um TAD que referencia um valor guardado em outro lugar (a origem), com três propriedades: não-posse: alterações na origem são percebidas pela vista; leve: custo constante O(1); validade: dura enquanto a origem existir.
Desafio: por que origem é do tipo
const int* e não int*?
Uma Vista Mutável é uma Vista que também possui
altera(v), que modifica o valor na
origem.
template <typename V>
concept VistaMutavelTAD = VistaTAD<V> &&
requires(V v, typename V::Tipo t) {
{ v.altera(t) }; // escrita na origem
};
struct VistaMutavelInt {
using Tipo = int; // tipo associado
Tipo* origem;
Tipo le() { return *origem; }
void altera(Tipo v) { *origem = v; }
};
static_assert(VistaMutavelTAD<VistaMutavelInt>);Desafio: VistaMutavelInt satisfaz
VistaTAD? E VistaInt satisfaz
VistaMutavelTAD?
As operações de uma vista de vetor, escritas como conceito:
template <typename V, typename T>
concept VistaVetorTAD = requires(V v, int i) {
{ v.tamanho() } -> std::same_as<int>;
{ v.le(i) } -> std::same_as<T>;
};
template <typename V, typename T>
concept VistaMutavelVetorTAD = VistaVetorTAD<V, T> &&
requires(V v, int i, T t) {
{ v.altera(i, t) };
}; // le e altera: pre(0 <= i < tamanho())
static_assert(VistaMutavelVetorTAD<SpanInt, int>);Note que fatia não é exigida: nem toda
vista precisa sabê-la.
Importante: a vista é passada por
valor (copia só um ponteiro e um int!), mas
altera muda o vetor original.
Desafio: por que
VistaMutavelVetorTAD<int> auto tem só
um parâmetro, se o conceito tem
dois?
Problema: dado um span v com
n elementos, rearranjá-los em ordem crescente.
O contrato de toda função ordena(v):
v.le(0) <= v.le(1) <= ... <= v.le(n-1)Desafio: escreva um “ordena” que satisfaça a pós-condição 1 e viole a 2. É fácil?
Basta for (i...) v.altera(i, 0);. Por isso as duas
condições são necessárias!
Veremos três algoritmos clássicos, todos usando
apenas as operações da vista: tamanho,
le e altera.
Já contamos os passos do Bubble Sort otimizado na Introdução. Agora, ele recebe uma vista:
Observação: o algoritmo não sabe que existe um vetor maior: a vista é o seu vetor.
Ideia: selecione o menor elemento
restante e coloque-o na posição i.
i=0: | 1 | 2 | 4 | 5 | 3 |
i=1: | 1 | 2 | 4 | 5 | 3 |
i=2: | 1 | 2 | 3 | 5 | 4 |
i=3: | 1 | 2 | 3 | 4 | 5 |
Vetor {5, 2, 4, 1, 3} ao fim de cada i: o
início (à esquerda) já está ordenado e definitivo.
Ideia: mantenha v[0..i-1] ordenado e
insira v[i] no lugar certo, deslocando os
maiores para a direita.
i=1: | 2 | 5 | 4 | 1 | 3 |
i=2: | 2 | 4 | 5 | 1 | 3 |
i=3: | 1 | 2 | 4 | 5 | 3 |
i=4: | 1 | 2 | 3 | 4 | 5 |
Vetor {5, 2, 4, 1, 3} ao fim de cada i: o
início está ordenado, mas não é definitivo.
Na Introdução, contamos linhas. Mas, assim como no Racional, o que importa depende do que é caro: ler (comparar) ou escrever?
| algoritmo | le (melhor) |
le (pior) |
altera (melhor) |
altera (pior) |
|---|---|---|---|---|
| Bubble (otimizado) | Θ(n) | Θ(n2) | 0 | Θ(n2) |
| Selection | Θ(n2) | Θ(n2) | 0 | Θ(n) |
| Insertion | Θ(n) | Θ(n2) | Θ(n) | Θ(n2) |
Altere os parâmetros dos métodos de ordenação para receber não um
SpanInt, mas um
VistaMutavelVetorTAD<int>. Com isso, é fácil
monitorar o número de passos real que o algoritmo
executa!
struct VistaContadora {
SpanInt s;
VistaMutavelInt leituras; // contadores na origem
VistaMutavelInt escritas; // (não-posse!)
int tamanho() { return s.tamanho(); }
int le(int i) {
leituras.altera(leituras.le() + 1);
return s.le(i);
}
void altera(int i, int v) {
escritas.altera(escritas.le() + 1);
s.altera(i, v);
}
};
static_assert(
VistaMutavelVetorTAD<VistaContadora, int>);Desafio: por que leituras é uma
VistaMutavelInt, e não um simples int? (Lembre
que a vista é passada por valor, inclusive para
troca!)
Use a VistaContadora para preencher a tabela, com
n=1000:
| entrada | Bubble (le / altera) |
Selection (le / altera) |
Insertion (le / altera) |
|---|---|---|---|
| já ordenado | |||
| decrescente | |||
| aleatório |
altera custasse 100
vezes mais que um le?Na STL, o std::span (que vimos na Introdução) cumpre o
papel do nosso SpanInt, e o std::ranges::sort
ordena qualquer vista:
import std;
int main() {
int b[] = {9, 5, 2, 4, 0};
std::span<int> s{b};
std::ranges::sort(s.subspan(1, 3)); // como nossa fatia(1, 4)
println("{}", b); // [9, 2, 4, 5, 0]
std::ranges::sort(s); // O(n log n)
println("{}", std::ranges::is_sorted(s)); // true
return 0;
}Importante: nesse curso é permitido o uso de TADs e algoritmos prontos da STL, desde que você saiba seu modelo de custos!
Mais adiante: veremos algoritmos
O(nlogn)
(Merge Sort e Quick Sort), que usam divisão e
conquista, e para isso a operação fatia será
essencial.
Racional1?
E de Racional2?igual é diferente nas duas implementações do
Racional?concept) verifica? O que ele
não verifica?Próxima aula: a Pilha, nosso primeiro TAD com duas implementações (sequencial e encadeada), e seu modelo de custos!
menor(r), nas
duas implementações. Qual o custo em cada uma? (Cuidado com o sinal do
denominador na Racional2!)Racional3 híbrida, que reduz apenas quando
|den| passa de um limite. Ela satisfaz
RacionalTAD? Monte o seu modelo de custos.bool ordenado(VistaVetorTAD<int> auto v),
que verifica a pós-condição 1 da ordenação. Note que ela só precisa da
vista não-mutável!SpanInvertido, que lê o
SpanInt de trás para frente. O que acontece se você ordenar
com ela?soma recursiva sem
fatia, usando apenas VistaVetorTAD. O que
precisou mudar?Além da bibliografia do curso, recomendamos para esse tópico:
Bibliografia Adicional:
Em especial, agradeço aos colegas que elaboraram bons materiais, como o prof. Fabiano Oliveira (IME-UERJ), e o prof. Jayme Szwarcfiter cujos conceitos formam o cerne desses slides.
Estendo os agradecimentos aos demais colegas que colaboraram com a elaboração do material do curso de Pesquisa Operacional, que abriu caminho para verificação prática dessa tecnologia de slides.
Esse material de curso só é possível graças aos inúmeros projetos de código-aberto que são necessários a ele, incluindo:
Agradecimento especial a empresas que suportam projetos livres envolvidos nesse curso:
Esses slides foram escritos utilizando pandoc, segundo o tutorial ilectures:
Exceto expressamente mencionado (com as devidas ressalvas ao material cedido por colegas), a licença será Creative Commons.
Licença: CC-BY 4.0 2020
Igor Machado Coelho