Ordinamento utilizzando stack di sola lettura

Considera la seguente impostazione:

• ci viene data una pila che contiene elementi.$s$$n$
• possiamo usare un numero costante di pile extra.$O(1)$
• possiamo applicare le seguenti operazioni su questi stack:
  1. controlla se uno stack è vuoto,
  2. confronta i primi oggetti di due pile,
  3. elimina l'elemento in cima a una pila,
  4. stampa l'articolo in cima a una pila,
  5. copia l'elemento in cima a una pila in un'altra pila,
  6. copia il contenuto di una pila in un'altra pila.

Si noti che queste sono le uniche operazioni consentite. Non siamo in grado di scambiare oggetti e non ci è permesso di inserire alcun oggetto in nessuna delle pile ad eccezione della copia dell'articolo in cima a una pila (dopodiché il contenuto precedente della pila di destinazione viene scartato e conterrà solo l'oggetto copiato) .

Ecco un algoritmo per ordinare le pile con confronti :$O(n^2)$

last := empty
for i from 1 to n
  min := empty
  w := s
  while w is not empty
    if w.top > last and w.top < min
      min := w.top
    delete w.top
  print min
  last := min

Possiamo fare di meglio?

Esiste un programma che stampa l'elenco ordinato degli elementi negli stack utilizzando solo confronti ?$O(n\log n)$

Penso di poter ora dimostrare un limite inferiore non banale. L'idea è quella di implementare tali programmi con una famiglia di programmi di ramificazione comparativa. Il presupposto di "sola lettura" significa che la nostra famiglia di programmi di ramificazione utilizza poco, ovvero spazio ) . Quindi applichiamo il limite inferiore S T = Ω ( n 2 ) dimostrato da Borodin et al. in "Un compromesso spazio-tempo per l'ordinamento su macchine non ignare". Questo ci dà un n 2 / log n limite inferiore per il tempo.$O(\log n)$$ST=\Omega(n^2)$$n^2/\log n$

Più in dettaglio: possiamo rinunciare all'operazione 5 sopra. In parole povere, se possiamo già confrontare le intestazioni di due liste e stampare la testa di una lista, non è necessario isolare la testa di una lista su un particolare registro. Supponendo ciò, vediamo che ogni registro nella macchina memorizza solo una sottostringa finale dell'input.

Supponiamo che il nostro programma di registro abbia righe di codice e registri k , X 1 , ... , X k .$\ell$$k$$X_1,\dots,X_k$

Fix . Costruiamo il programma di ramificazione comparativa per stringhe di lunghezza n come segue. Crea un nodo per ogni tupla ( i , d 1 , … , d k ) dove 1 ≤ i ≤ ℓ e 0 ≤ d 1 , … , d k ≤ n . L'idea è che i calcoli nella macchina del registro corrispondono ai percorsi nel programma di diramazione e siamo al nodo ( i , d 1 , ... , $n$$n$$(i,d_1,\dots,d_k)$$1\le i\le \ell$$0\le d_1 ,\dots, d_k \le n$ se siamo alla riga i nella macchina del registro e la lunghezza della stringa memorizzata in X i è d i . Ora, dobbiamo definire i bordi diretti del programma di ramificazione$(i,d_1 ,\dots, d_k)$$i$$X_i$$d_i$

Se la riga è del modulo$i$

se poi goto i 1 altro goto i $X_u<X_v$$i_1$$i_2$

quindi per tutto , il nodo ( i , d 1 , ... , d k ) viene etichettato confrontando l' elemento d u -th e d v -th dell'input e facendo in modo che il bordo "vero" vada a ( i 1 , d 1 , $d_1,\dots,d_k$$(i,d_1,\dots,d_k)$$d_u$$d_v$ e il bordo "falso" su ( i 2 , d 1 , ... , d $(i_1,d_1,\dots,d_k)$ .$(i_2,d_1,\dots,d_k)$

Se la riga è del modulo$i$

, vai alla linea i $X_1 \leftarrow tail(X_2)$$i'$

poi c'è una freccia da qualsiasi nodo a ( i ′ , d 2 - 1 , ... , d k ) .$(i,d_1,\dots,d_k)$$(i',d_2-1,\dots,d_k)$

Se la riga è del modulo$i$

, vai alla riga i $print(head(X_u))$$i'$

poi c'è una freccia da qualsiasi nodo a ( i ′ , d 1 , ... , d k ) che è etichettata dal nodo d u dell'ingresso.$(i,d_1,\dots,d_k)$$(i',d_1,\dots,d_k)$$d_u$

Spero che questi esempi chiariscano come intendo costruire il mio programma di diramazione. Quando tutto è detto e fatto, questo programma di ramificazione ha al massimo nodi, quindi, dispone di spazi O ( log n $\ell\cdot n^k$$O(\log n)$

Sei in grado di contare gli elementi? Quindi, penso, ci sia un'implementazione Mergesort abbastanza semplice. Se fossi in grado di mettere simboli aggiuntivi in ​​pila, potresti risolverlo con 3 pile in questo modo:

Se abbiamo un solo elemento, l'elenco è già ordinato. Ora supponiamo che abbiamo già ordinato la metà superiore dello stack. Possiamo copiare la metà superiore (in ordine inverso) nella seconda pila e posizionare sopra di essa un simbolo di separazione. Ora abbiamo di nuovo 3 pile (poiché possiamo ignorare i simboli già ordinati sotto il simbolo di separazione) e possiamo ordinare la metà inferiore. Finalmente possiamo copiare la metà inferiore ordinata in una terza pila in ordine inverso e unire entrambe le metà nella pila originale.

Tutte le operazioni costano tempo lineare, pertanto abbiamo ordinato l'elenco in $O(n \log n)$

(Si noti che abbiamo bisogno di pile di dimensioni causa dei simboli di separazione, ma questo può essere facilmente corretto usando un altro stack)$n \log n$

Dato che non puoi mettere nuovi elementi in pila, potresti avere problemi nei punti di separazione. Per risolvere questo problema puoi fare quanto segue con alcune pile aggiuntive:

Copia la parte superiore $n-2^{\lfloor \log n\rfloor}$

Infine ripetere la procedura con gli elementi aggiuntivi al massimo volte e li fondono alla pila originale in tempo lineare. Ordinamento dei costi pile, per qualche costante c , al massimo c n $\log n$$c$$cn \log n+c\frac{n}{2} \log \frac{n}{2}+c\frac{n}{4} \log \frac{n}{4}+\ ... = O(n \log n)$$O(n \log n)$