Un problema di heap d-ary da CLRS

Mi sono confuso mentre risolvo il seguente problema (domande 1–3).

Domanda

Un heap d -ary è come un heap binario, ma (con una possibile eccezione) i nodi non foglia hanno d figli invece di 2 figli.

Come rappresenteresti un heap d -ary in un array?

Qual è l'altezza di un heap d -ary di n elementi in termini di n e d ?

Fornire un'implementazione efficiente di EXTRACT-MAX in un d -ary max-heap. Analizzare il suo tempo di esecuzione in termini di d e n .

_{Fornire un'implementazione efficiente di INSERT in un max-heap d -ary. Analizzare il suo tempo di esecuzione in termini di d e n .}

_{Fornire un'implementazione efficiente di INCREASE-KEY ( A , i , k ), che contrassegna un errore se k <A [i] = k e quindi aggiorna la struttura heap della matrice d -ary in modo appropriato. Analizzare il suo tempo di esecuzione in termini di d e n .}

La mia soluzione

Assegna un array $A[a_1 .. a_n]$

$\qquad \begin{align} \text{root} &: a_1\\ \text{level 1} &: a_{2} \dots a_{2+d-1}\\ \text{level 2} &: a_{2+d} \dots a_{2+d+d^2-1}\\ &\vdots\\ \text{level k} &: a_{2+\sum\limits_{i=1}^{k-1}d^i} \dots a_{2+\sum\limits_{i=1}^{k}d^i-1} \end{align}$

→ La mia notazione sembra un po 'sofisticata. Ce n'è un altro più semplice?
Let h indica l'altezza dell'heap d -ary.

Supponiamo che l'heap sia un albero d -ary completo
$1 + d + d^{2} + . . + d^{h} = n \frac{d^{h + 1} - 1}{d - 1} = n h = l o g_{d} [n d - 1 + 1] - 1$ $1+d+d^2+..+d^h=n\\ \dfrac{d^{h+1}-1}{d-1}=n\\ h=log_d[n{d-1}+1] - 1$
Questa è la mia implementazione:
```
EXTRACT-MAX(A)
1  if A.heapsize < 1
2      error "heap underflow"
3  max = A[1]
4  A[1] = A[A.heapsize]
5  A.heap-size = A.heap-size - 1
6  MAX-HEAPIFY(A, 1)
7  return max

MAX-HEAPIFY(A, i)
1  assign depthk-children to AUX[1..d]
2  for k=1 to d
3      compare A[i] with AUX[k]
4      if A[i] <= AUX[k]
5          exchange A[i] with AUX[k]
6          k = largest
7  assign AUX[1..d] back to A[depthk-children]
8  if largest != i
9      MAX-HEAPIFY(A, (2+(1+d+d^2+..+d^{k-1})+(largest-1) )
```
- Il tempo di esecuzione di MAX-HEAPIFY:
  
  $T_{M} = d (c_{8} * d + (c_{9} + . . + c_{1} 3) * d + c_{1} 4 * d)$ $T_M = d(c_8*d + (c_9+..+c_13)*d +c_14*d)$ dove denota il costo dei -esimo linea sopra. $c_i$
- EXTRACT-MAX:
  $T_{E} = (c_{1} + . . + c_{7}) + T_{M} \leq C * d * h = C * d * (l o g_{d} [n (d - 1) + 1] - 1) = O (d l o g_{d} [n (d - 1)])$ $T_E = (c_1+..+c_7) + T_M \leq C*d*h\\ = C*d*(log_d[n(d-1)+1] - 1)\\ = O(dlog_d[n(d-1)])$
→ È una soluzione efficiente? O c'è qualcosa di sbagliato nella mia soluzione?

data-structures time-complexity runtime-analysis

— lucasKo
fonte

Penso che ci sia un piccolo errore nella domanda e nella spiegazione: L'altezza dell'heap d-ary arriva a h = (log [nd - n + 1]) - 1 // NOTA è "-n" e non "-1" e non h = (log [nd−1+1])− 1Pertanto la spiegazione sopra l'altezza non sarà valida. h = log [nd − 1 + 1] −1 = log [nd] -1 = log [n] Sebbene comunque, l'altezza dell'albero è scritta come Θ(log(n)).Nota: il log è sempre alla base d per un heap d-ary .

— Surabhi Raje,

Risposte:

La tua soluzione è valida e segue la definizione di heap d -ary. Ma come hai sottolineato la tua notazione è un po 'sofisticata.

È possibile utilizzare le due seguenti funzioni per recuperare parent of i -th element e j -th child of i -th element.

$\text{d-ary-parent}({\it i}) \\ \ \ \ \ {\bf return}\ \lfloor (i-2)/d + 1 \rfloor$

$\text{d-ary-child}(i, j) \\ \ \ \ \ {\bf return}\ d(i-1)+j+1$

Ovviamente . Puoi verificare quelle funzioni controllando che $1 \le j \le d$ $\text{d-ary-parent}(\text{d-ary-child}(i,j)) = i$

È anche facile vedere che l'heap binario è un tipo speciale di heap -ary dove , se sostituisci con , vedrai che corrispondono alle funzioni PARENT, LEFT e RIGHT menzionate nel libro. $d$ $d=2$ $d$ $2$
Se capisco correttamente la tua risposta, usi una progressione geometrica . Nel tuo caso vai go , che è ovviamente , che in realtà è una soluzione valida e corretta. Ma solo per gestire fluttuazioni costanti potresti voler scrivere . $h = log_d(n\,d-1+1) - 1$ $\log_d(n\,d) - 1 = \log_d(n) + \log_d(d) - 1 = \log_d(n) + 1 - 1 = \log_d(n)$ $\Theta(\log_d(n))$

La ragione di ciò è che alcuni cumuli potrebbero non essere bilanciati, quindi il loro percorso più lungo e il percorso più breve possono variare di qualche costante , usando la notazione si elimina questo problema. $c$ $\Theta$
Non è necessario implementare nuovamente la procedura fornita nel libro di testo, ma è necessario modificarla un po ', ad es. Assegnando tutti i bambini alla tabella usando e funzioni. $AUX$ $\text{d-ary-parent}$ $\text{d-ary-child}$

Poiché non è stato modificato, dipende dal tempo di esecuzione di . Nella tua analisi ora devi usare il tempo peggiore proporzionale all'altezza e al numero di bambini che ciascun nodo deve esaminare (che è al massimo d ). Ancora una volta la tua analisi è molto precisa, alla fine hai ottenuto , che può essere trasformato in: $\text{EXTRACT-MAX}$ $\text{MAX-HEAPIFY}$ $O(d\ \log_d(n(d-1)))$

$O(d\ \log_d(n(d-1))) = O(d(\log_d(n) + \log(d-1))) = O(d\ log_d(n) + d\ \log_d(d-1))$

Per motivi pratici possiamo sempre presumere che , quindi possiamo perdere la parte della notazione O , quindi otterremo . Qual è anche una soluzione valida. Ma non sorprende che tu possa anche analizzare il tempo di esecuzione della funzione usando il teorema del Maestro , che mostrerà che non è solo ma anche . $d \ll n$ $d \log_d(d-1)$ $O(d\log_d(n))$ $\text{MAX-HEAPIFY}$ $O$ $\Theta$
Il libro CLRS fornisce già la procedura INSERT. Che assomiglia a questo:

$\text{INSERT}(A, key)\\ \ \ \ \ A.heap\_size = A.heap\_size + 1 \\ \ \ \ \ A[A.heap\_size] = -\infty\\ \ \ \ \ \text{INCREASE-KEY}(A, A.heap\_size, key)$

Può essere facilmente provato, ma il buon senso impone che la sua complessità temporale sia . È perché l'heap potrebbe essere attraversato fino alla radice. $O(\log_d(n))$
Proprio come INSERT, INCREASE-KEY è anche definito nel libro di testo come:

$\text{INCREASE-KEY}(A, i, key)\\ \ \ \ \ {\bf if}\ key < A[i]\\ \ \ \ \ \ \ \ \ {\bf error} \text{"new key is smaller then current"}\\ \ \ \ \ A[i] = key\\ \ \ \ \ {\bf while}\ i > 1\ and\ A[i] > A[\text{d-ary-parent}(i)]\\ \ \ \ \ \ \ \ \ A[i] \leftrightarrow A[\text{d-ary-parent(i)}]\\ \ \ \ \ \ \ \ \ i = \text{d-ary-parent(i)}$

La complessità è ovviamente (vedi punto precedente). $O(\log_d(n))$

— Bartosz Przybylski
fonte

Grazie! Che ne dici dell'implementazione di INCREASE-KEY e INSERT? Provo a scriverlo, ma mi ha dato due volte ricorsive di MAX-HEAPIFY. C'è una soluzione migliore? Ho trovato poche informazioni su web e wiki

— lucasKo

È quel resto dell'esercizio? In tal caso, aggiorna la tua domanda e sarò felice di rispondere al tema.

— Bartosz Przybylski,

Ho posto quelle domande sul post modificato.

— lucasKo

reimplementare la procedura INSERT? Vuoi dire, non deve chiamare la procedura che regola l'ordine all'interno dell'heap, dopo aver inserito un nuovo elemento? Non capisco ...

— lucasKo

Quella descrizione è stata un po 'sfortunata, vedi le modifiche per la clearificazione.

— Bartosz Przybylski,

Questa non è una risposta completa. parte b) la soluzione non è Its come sottolineato dall'utente 55463 (perché non può commentare, ma rispondere), ma ha effettuato il downgrade per mancanza di spiegazioni . Anche la risposta votata ha risolto per errore. La risposta sarà ancora Fonte: Problema 2-2. Analisi di cumuli di dary, parte b)

h = l o g_{d} [n d - 1 + 1] - 1

$h=log_d[n{d-1}+1] - 1$

1 + d + d^{2} + . . + d^{h} = n \frac{d^{h + 1} - 1}{d - 1} = n h = l o g_{d} [n (d - 1) + 1] - 1

$1+d+d^2+..+d^h=n\\ \dfrac{d^{h+1}-1}{d-1}=n\\ h=log_d[n(d-1)+1] - 1$

h = Θ (\log_{d} (n))

$h=\Theta(\log_d(n))$

— Ali Jazib Mahmood
fonte

-1

La risposta alla seconda domanda è h = log _d (n (d-1) + 1) - 1 Quindi, h = log _d (nd - n + 1) - 1

— user55463
fonte

Perché questa è la risposta? Una formula senza spiegazione non aiuta davvero nessuno.

— David Richerby,