Estruturas de Dados I

Implementação Heap1

Consideraremos uma fila sequencial com, no máximo, MAXN elementos do tipo caractere.

constexpr int MAX_N = 50; // capacidade máxima da fila
class Heap1
{
public:
  int elementos [MAX_N];      // elementos na fila
  int N;                     // num. de elementos na fila
  void cria () { ... }       // inicializa agregado
  void libera () { ... }     // finaliza agregado
  int frente () { ... }
  void insere (int chave){ ... }
  int remove () { ... }
};
// verifica se agregado Heap1 satisfaz conceito FilaPrioridadeTAD
static_assert(FilaPrioridadeTAD<Heap1, int>);

Implementação Heap1 - cria/libera

A operação cria inicializa a fila para uso, e a função libera desaloca os recursos dinâmicos.

class Heap1 {
...
void cria() {
   this->N = 0;
}

void libera() {
   // nenhum recurso dinâmico para desalocar
}
...
}

Implementação Heap1 - frente

A operação frente retorna a raiz do heap, ou seja, o primeiro elemento. Este é sempre o mais prioritário.

class Heap1 {
...
int frente() {
   return this->elementos[0];
}
...
}

Representação por níveis (árvore completa):

| 3* | 10 | 7 | 11 | 19 | 35 | 8 | 14 | 12 | 22 | 30 | 44 |

Implementação Heap1 - `pai` e `filho`

Métodos auxiliares pai e filho.

class Heap1 {
...
int pai(int pos) {
  return (pos - 1) / 2;
}

int filho1(int pos) {
  return (2 * pos) + 1;
}

int filho2(int pos) {
  return filho1(pos) + 1;
}
...
}

Representação por níveis:

| 3 | 10 | 7 | 11 | 19 | 35 | ...
  0   1    2   3    4    5

Implementação Heap1 - sobe

A operação sobe compara sistematicamente um nó com seu pai, efetuando trocas enquanto a prioridade estiver incorreta. Custo: proporcional ao nível.

class Heap1 {
...
void sobe(int pos) {
  int p = pai(pos);
  while (pos > 0) {
    // compara filho com pai
    if (elementos[pos] >= 
                 elementos[p]);
      break;
    troca(p, pos, elementos);
    pos = p;     // repete
    p = pai(pos);
  }
}
...
}

Representação por níveis:

| 3 | 10 | 7 | 11 | 19 | 35 | ...
  | 8 | 14 | 12 | 22 | 30 | 44 |

Implementação Heap1 - insere

O método insere coloca o novo elemento no final do heap e invoca a operação sobe. Custo: altura da árvore.

class Heap1 {
...
void insere(int pos) {
  elementos[N] = pos;
  N++;
  sobe(N-1);
}
...
}

Representação por níveis:

| 3 | 10 | 7 | 11 | 19 | 35 | ...
  | 8 | 14 | 12 | 22 | 30 | 44 |

Implementação Heap1 - desce

A operação desce compara um nó com seus filhos, trocando enquanto a prioridade for incorreta. Custo: proporcional ao nível.

class Heap1 {
...
void desce(int pos) {
  int f = filho1(pos);
  while (f < N) {
    // existe segundo filho?
    if ((f < N-1) && 
(elementos[f+1]<elementos[f]))
      f = f + 1;
    if (elementos[f] >= 
           elementos[pos]) break;
    troca(f, pos, elementos);
    pos = f;  f = filho1(pos);
  }
}
...
}

Representação por níveis:

| 3 | 10 | 7 | 11 | 19 | 35 | ...
  | 8 | 14 | 12 | 22 | 30 | 44 |

Implementação Heap1 - remove

O método remove troca o primeiro com último elemento e invoca a operação desce. Custo: altura da árvore.

class Heap1 {
...
int remove() {
  troca(0, N-1, elementos);
  N--;
  desce(0);
  return elementos[N];
}
...
}

Representação por níveis:

| 3 | 10 | 7 | 11 | 19 | 35 | ...
  | 8 | 14 | 12 | 22 | 30 | 44 |

Heapify / Constroi

A construção de um heap através de um vetor é chamada de heapify. É possível efetuar a construção de forma iterativa, através dos métodos sobe ou desce.

Como vimos anteriormente, o método sobe custa, no máximo, o nível do nó, enquanto o método desce custa, no máximo, a altura do nó.

Veja as alturas dos nós (N=23): vermelho(5), azul(4), roxo(3), amarelo(2), verde(1). Metade dos nós (12) tem altura 1.

Heapify com sobe

A construção do heap ( $N=31$ ) com o método sobe opera sequencialmente a partir dos nós $1,2,3,4...$ , e a raiz não efetua nenhuma troca. Cada elemento folha ( $\approx N/2$ ) irá incorrer em $O(h=\lceil lg\;N \rceil)$ trocas, no pior caso, tendo assim complexidade $O(N\;lg\;N)$ .

nós: | 0 | 1 | 2 | 3 | 4 | ... ->

Método Heapify com sobe

class Heap1 {
...
void constroi_sobe(int v[], int N) {
  for (int i = 1; i < N; i++)
     this->elementos[i] = v[i];
  this->N = N;
  for (int i = 1; i < N; i++)
    sobe(i);
}
...
}

Heapify com desce

A construção do heap ( $N=31$ ) com o método desce toma vantagem de que as folhas ( $\approx N/2$ ) tem altura 1, portanto não necessitando de troca alguma. O método opera sequencialmente em ordem decrescente a partir do nó $\lfloor N/2 \rfloor -1=14$ como $14,13,12,11,10,...$ . Note que um único elemento (a raiz) irá incorrer em $O(h=\lceil lg\;N \rceil)$ trocas, sendo a complexidade $O(N\;lg\;N)$ superestimada neste caso.

nós: | 0 | 1 | ... <- | 10 | 11 | 12 | 13 | 14 | ...

Método Heapify com desce

class Heap1 {
...
void constroi_desce(int v[], int N) {
  for (int i = 1; i < N; i++)
     this->elementos[i] = v[i];
  this->N = N;
  for (int i = N / 2 - 1; i >= 0; i--)
    desce(i);
}
...
}

Análise do Método Heapify com desce

Consideramos uma árvore com $N$ nós e $h=\lceil lg\;N\rceil$ níveis. No nível 1, um único nó (a raiz) efetua $h-1$ trocas, no pior caso. Por outro lado, existem $2^{h-1}$ folhas que não fazem nenhuma troca.

De forma geral, no nível $i$ , cada um dos $2^{i-1}$ nós efetuam $h-i$ trocas, no pior caso, totalizando $\sum_{i=1}^{h-1}\left(2^{i-1} (h-i)\right)$ trocas.

Análise do Método Heapify com desce

Temos que $\sum_{i=1}^{h-1}\left(2^{i-1} (h-i)\right) = 2^h - (h+1)$ , dado que $\sum_{i=0}^m 2^i = 2^{m+1}-1$ . Desmembramos em cada linha $i$ abaixo as $h-i$ ocorrências de $2^{i-1}$ , de $i=1$ até $h-1$ . Efetuamos então uma soma por colunas.

$\begin{matrix} \\ i=1: \\ i=2: \\ i=3: \\ i=4: \\ i: \\ i=h-2: \\ i=h-1: \\ \\ \\ \end{matrix} \overbrace{ \begin{matrix} & 1 & + & 1 & + \cdots + & 1 & + & 1 & + & 1 & + & 1 & \\ + & 2 & + & 2 & + \cdots + & 2 & + & 2 & + & 2 \\ + & 4 & + & 4 & + \cdots + & 4 & + & 4 \\ + & 8 & + & 8 & + \cdots + & 8 \\ + & \cdots & + & \cdots & + \cdots \\ + & 2^{h-3} & + & 2^{h-3}\\ + & 2^{h-2} & + \\ = & \sum_{i=0}^{h-2}2^i & + & \sum_{i=0}^{h-3}2^i & + \cdots + & \sum_{i=0}^{3}2^i & + & \sum_{i=0}^{2}2^i & + & \sum_{i=0}^{1}2^i & + & \sum_{i=0}^{0}2^i \\ \end{matrix} }^{H-1}$

$\begin{matrix} =& (2^{h-1}-1) + (2^{h-2}-1) &+ \cdots +& (2^3-1) + (2^2-1) + (2^1-1)\\ =& 2^{h-1} + 2^{h-2} &+ \cdots +& 2^3 + 2^2 + 2^1 - (h-1)\\ =& \sum_{i=0}^{h-1} 2^i - h &=& 2^h - (h+1) \qed \end{matrix}$

Análise do Método Heapify com desce

Temos então que o total de trocas do heapify é $2^h -(h+1)$ , e considerando uma altura $h=\lceil lg\;N \rceil=O(lg\;N)$ , temos:

$2^{O(lg\;N)} - (O(lg\;N) + 1) = O(N)$

Na prática, para $N=31$ e, portanto, $h=5$ , temos: $8\times 1 +4\times 2+ 2\times 3 + 1 \times 4 = 26$ trocas.

Veja código em materiais.

Agradecimentos ao Prof. Fabiano Oliveira, pelo embasamento dessa prova.

Bibliografia Recomendada

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

Szwarcfiter, J.L; Markenzon, L. Estruturas de Dados e seus Algoritmos. Rio de Janeiro, LTC, 1994. Bibliografia Adicional:
Cerqueira, R.; Celes, W.; Rangel, J.L. Introdução a estruturas de dados: com técnicas de programação em C. Editora, 2004.
Cormen, T.H.; Leiserson, C.E.; Rivest, R.L.; Stein Algoritmos: Teoria e Prática. Ed. Campus, 2002.
Cormen, T.H.; Leiserson, C.E.; Rivest, R.L.; Stein, C. Introduction to Algorithms, 3rd ed.. The MIT Press, 2009.
Preiss, B.R. Estruturas de Dados e Algoritmos Ed. Campus, 2000;
Knuth, D.E. The Art of Computer Programming - Vols I e III. 2nd Edition. Addison Wesley, 1973.
Graham, R.L., Knuth, D.E., Patashnik, O. Matemática Concreta. Segunda Edição, Rio de Janeiro, LTC, 1995.
Livro “The C++ Programming Language” de Bjarne Stroustrup
Dicas e normas C++: https://github.com/isocpp/CppCoreGuidelines