curso-estruturas-de-dados-i

Tópico Avançado: Saco Ordenado


Saco Ordenado: Motivação

Esta parte é curta e serve como motivação para as próximas aulas.

No Saco, a busca custa $O(n)$: sem ordem, é preciso olhar tudo (desafio do Percorrível!).

E se mantivermos os elementos sempre ordenados, como no Conjunto Ordenado?


Saco Ordenado

Um Saco Ordenado é um Saco cujo vetor satisfaz a invariante:

\[v[0] \leq v[1] \leq \cdots \leq v[N-1] \qquad (\leq \text{, pois há repetições!})\]

Consequência: seu iterador visita os elementos em ordem crescente.

Lembrete: no Saco, removíamos trazendo o último para o buraco. Por que isso agora é proibido?


Saco $\times$ Saco Ordenado

::: -

Operação Saco (vetor) Saco Ordenado (vetor)
adiciona $O(1)$ $O(n)$: abre espaço
remove $O(1)$: traz o último $O(n)$: fecha o buraco
busca $O(n)$ $\mathbf{O(\log n)}$
percorrer $O(n)$, ordem qualquer $O(n)$, ordem crescente
contar cópias de x $O(n)$ $\mathbf{O(\log n)}$
menor / maior $O(n)$ $\mathbf{O(1)}$: nas pontas
intervalo $[a, b]$ ($k$ elementos) $O(n)$ $\mathbf{O(\log n + k)}$

:::

Vale a pena quando há muitas consultas e poucas atualizações.


Buscas por Ordem: buscaMaiorIgual e buscaMaior

Motivação: pense em uma estante. Para guardar mais um d em uma estante ordenada, há um primeiro e um último lugar possível:

   a | d   d   d | f
     ^           ^
   0   1   2   3   4  
  buscaMaiorIgual('d') = 1      buscaMaior('d') = 4
  (1o elemento >= d)            (1o elemento > d)

Na STL existem lower_bound (buscaMaiorIgual) e upper_bound (buscaMaior), e no Java ceiling e higher.


Revisão: Iterador de Vetor

O Saco Ordenado usa o mesmo iterador do Saco em vetor (veja mais detalhes nos slides de Sacos):

::: -

::::::::::  
::::: {50%}
struct IteradorVetor1 {
   using Tipo = char;  // tipo associado
   const char* atual;  // posição atual
   const char* fim;    // após o último
   char le()       { return *atual; }
   bool terminou() { return atual == fim; }
   void proximo()  { atual++; }
};
static_assert(IteradorTAD<IteradorVetor1, char>);

:::::

::::: {45%}

Um par (atual, fim) delimita uma faixa do vetor: as buscas deste tópico só escolhem onde ela começa e termina!

:::::

::::::::::

:::


Conceito: Saco Ordenado

Um Saco Ordenado é um Saco com elementos comparáveis e com as duas buscas por ordem:

::: -

::::::::::  
::::: {50%}
template <typename S, typename T>
concept SacoOrdenadoTAD = SacoTAD<S, T> &&
   std::totally_ordered<T> &&  // comparáveis
   requires(S s, T t) {
   // 1a posição com elemento >= t
   { s.buscaMaiorIgual(t) } -> IteradorTAD<T>;
   // 1a posição com elemento > t
   { s.buscaMaior(t) } -> IteradorTAD<T>;
};

:::::

::::: {45%}
struct SacoOrdenado1 {
   char elementos[MAX_N]; // sempre ordenado
   int N;                 // num. de elementos
   // ... operações do Saco ...
   IteradorVetor1 buscaMaiorIgual(char x);
   IteradorVetor1 buscaMaior(char x);
};
static_assert(SacoOrdenadoTAD<SacoOrdenado1, char>);

:::::

::::::::::

:::

Atenção: o conceito verifica que as buscas existem, mas não que o vetor está ordenado: essa invariante o compilador não consegue verificar!


Implementação: SacoOrdenado1

Consideraremos um vetor de caracteres pré-alocado com capacidade MAX_N, sempre ordenado.

::: -

::::::::::  
::::: {50%}
struct SacoOrdenado1 {
   char elementos[MAX_N]; // sempre ordenado
   int N;                 // num. de elementos
   void cria();                          // vazio
   void cria(IteradorTAD<char> auto it); // cópia
   void libera();
   void adiciona(char x);
   IteradorVetor1 iterador();
   IteradorVetor1 busca(char x);
   IteradorVetor1 remove(IteradorVetor1 it);
   int tamanho();
   IteradorVetor1 buscaMaiorIgual(char x);
   IteradorVetor1 buscaMaior(char x);
};
static_assert(SacoOrdenadoTAD<SacoOrdenado1, char>);

:::::

::::: {45%}
// iguais ao SacoVetor1:
void cria()    { N = 0; }
void libera()  { N = 0; }
int tamanho()  { return N; }

IteradorVetor1 iterador() {
   return {.atual = elementos,
           .fim   = elementos + N};
}

O cria(it), que cria a partir de outro saco, veremos mais adiante.

:::::

::::::::::

:::


Implementação: Buscas

::: -

::::::::::  
::::: {50%}
// primeira posição com elemento >= x
IteradorVetor1 buscaMaiorIgual(char x) {
   // busca em [ini, fim)
   int ini = 0, fim = N;  
   while (ini < fim) {
      int meio = ini + (fim - ini) / 2;
      if (elementos[meio] < x)
         ini = meio + 1;
      else
         fim = meio;
   }
   return {.atual = elementos + ini,
           .fim   = elementos + N};
}

:::::

::::: {45%}
// primeira posição com elemento > x
IteradorVetor1 buscaMaior(char x) {
   // idêntica, trocando a comparação:
   //   if (elementos[meio] <= x)
   ...
}

IteradorVetor1 busca(char x) {
   auto it = buscaMaiorIgual(x);
   if (!it.terminou() && it.le() == x)
      return it;
   return {.atual = elementos + N,
           .fim   = elementos + N};
}

:::::

::::::::::

:::


Implementação: Adiciona e Remove

::: -

::::::::::  
::::: {50%}
void adiciona(char x) {
   // após as cópias de x
   int p = buscaMaior(x).atual - elementos;
   for (int i = N; i > p; i--)
      elementos[i] = elementos[i - 1];
   elementos[p] = x;      // abriu espaço
   N++;
}

:::::

::::: {45%}
IteradorVetor1 remove(IteradorVetor1 it) {
   int i = it.atual - elementos;
   for (int j = i; j < N - 1; j++)
      elementos[j] = elementos[j + 1];
   N--;                    // fechou o buraco
   return {.atual = elementos + i,
           .fim   = elementos + N};
}

:::::

::::::::::

:::

Ambas $O(n)$: achar o lugar é rápido, deslocar é que custa. O contrato de remove é o mesmo do Saco!


Usando as Buscas: Contar e Intervalo

::: -

::::::::::  
::::: {50%}
int conta(char x) {
   return buscaMaior(x).atual
        - buscaMaiorIgual(x).atual;
}

// elementos em [a, b]   (pre: a <= b)
IteradorVetor1 intervalo(char a, char b) {
   return 
   {.atual = buscaMaiorIgual(a).atual,
    .fim   = buscaMaior(b).atual};
}

:::::

::::: {45%}
// saco: a b d d d f g
println("{}", s.conta('d'));  // 3
println("{}", s.conta('c'));  // 0

auto it = s.intervalo('b', 'f');
while (!it.terminou()) {
   println("{}", it.le()); // b d d d f
   it.proximo();
}

:::::

::::::::::

:::

O intervalo é apenas um iterador com outro fim: uma vista de uma faixa do saco!


Criando a Partir de Outro Saco em $O(n \log n)$

Como criar um Saco Ordenado com os $n$ elementos de outro saco?

::: -

Estratégia Custo
$n$ chamadas de adiciona $O(n^2)$: cada uma desloca
copiar + Insertion Sort $O(n^2)$ no pior caso, $O(n)$ se já ordenado
copiar + Merge Sort $\mathbf{O(n \log n)}$ sempre
void cria(IteradorTAD<char> auto it) {  // iterador de QUALQUER saco
   N = 0;
   while (!it.terminou()) {              // O(n): copia
      elementos[N] = it.le();
      N++;      it.proximo();
   }
   ordena();   // O(n log n) com Merge Sort (aula de Conjuntos Simples)
}

Desafio: faça o ordena()! Se a origem for outro Saco Ordenado, qual ordenação você escolheria?

:::


Para Onde Vamos

Pergunta final: no Saco Ordenado, achamos o lugar em $O(\log n)$, mas deslocamos em $O(n)$. Que estrutura evitaria o deslocamento?

Bibliografia Recomendada

Além da bibliografia do curso, recomendamos para esse tópico:

Agradecimentos


Pessoas

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.


Software

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:


Empresas

Agradecimento especial a empresas que suportam projetos livres envolvidos nesse curso:


Reprodução do material

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


This Slide Is Intentionally Blank (for goomit-mpx)