Algoritmo per trovare la minima differenza nell'array

Vogliamo un algoritmo che, data una matrice di lunghezza di numeri interi, trovi la differenza minima tra due numeri interi nella matrice. $n$

Uno di questi algoritmi è quello di ordinare l'array e controllare coppie di numeri adiacenti. Questo richiede tempo . $O(n\log n)$

Esiste un modo più veloce, ad esempio un algoritmo ? $O(n)$

algorithms arrays

— boaten
fonte

O (n)

$O(n)$ non è più veloce di

O (n \log n)

$O(n\log n)$

— David Merinos,

Risposte:

Questo dipende dal tuo modello di calcolo. Se si consentono solo l'aritmetica e i confronti (il modello dell'albero delle decisioni algebrico), esiste un limite inferiore per la distinzione degli elementi , il problema di decidere se tutti gli elementi sono distinti. Il tuo problema è ovviamente ancora più difficile, quindi si applica lo stesso limite inferiore. $\Omega(n\log n)$

(C'è qualche buona stampa: il limite inferiore vale solo se il grado dei polinomi da confrontare è limitato. Se tutto ciò che stai facendo è confrontare varie differenze , allora sei a posto. Il modello dell'albero delle decisioni algebrico consente inoltre di confrontare i polinomi più generali negli input, purché abbiano un grado limitato.) $x_i - x_j$

Esistono altri modelli che potrebbero offrire prestazioni migliori, ad esempio in alcuni modelli è possibile ordinare numeri interi in . Ma immagino che tu non voglia permettere il tipo di inganno usato in tali algoritmi. $o(n\log n)$

— Yuval Filmus
fonte

Grazie. Che cosa intendi con "confrontare varie differenze "? Dal momento che esistono tali coppie, ciò non richiederebbe tempo ?

x_{i} - x_{j}

$x_i-x_j$

Θ (n^{2})

$\Theta(n^2)$

Ω (n^{2})

$\Omega(n^2)$

— Boaten

Non necessariamente. Gli algoritmi basati sul confronto possono solo confrontare coppie di elementi. Qui ti sto permettendo di fare domande più complicate come

x_{1} - x_{2} > x_{3} - x_{4}

$x_1 - x_2 > x_3 - x_4$ , o anche

x_{1} + 5 x_{8} - 17 x_{3} < - 5

$x_1 + 5x_8 - 17x_3 < -5$ . Sappiamo che esiste una soluzione che utilizza

O (n \log n)

$O(n\log n)$ confronti del tipo

x_{i} > x_{j}

$x_i > x_j$ , e

O (n)

$O(n)$ confronti del tipo

x_{i} - x_{j} > x_{k} - x_{ℓ}

$x_i - x_j > x_k - x_\ell$ . La domanda è: puoi fare di meglio, e la risposta è no, se sei limitato a fare solo domande lineari (o, più in generale, domande di laurea limitate).

— Yuval Filmus,

Non sono sicuro di capire il significato pratico di questo limite per la distinzione degli elementi. Non avresti una O (n) attesa con una tabella hash?

— jkff,

Una tabella hash non può essere implementata usando questo modello di calcolo. In generale, i limiti inferiori sono difficili da dimostrare. Il modello dell'albero delle decisioni algebrico è quello in cui sono provabili limiti inferiori non banali. Non vedo come dimostrarlo

ω (n)

$\omega(n)$ limite inferiore in qualsiasi altro modello - in effetti, tali limiti inferiori sono generalmente noti solo per funzioni casuali. Hai ragione che potrebbe esserci un trucco

o (n \log n)

$o(n\log n)$ algoritmo che va oltre questo modello, ma non riesco a pensare a nessuno.

— Yuval Filmus,

-1

Se gli interi nell'array hanno un numero limitato di cifre, è possibile ordinare un array con algoritmo di ordinamento radix , ovvero O (kN) e quindi controllare le coppie di numeri adiacenti (O (N))? La complessità risultante sarà O ((k + 1) N), lineare.

— Pavel Davydov
fonte

Prestare attenzione alle condizioni in cui il tempo di esecuzione di radix sort è effettivamente buono.

— Raffaello

@Raphael Bene, la domanda originale era l'esistenza dell'algoritmo lineare, quindi ci ho pensato. Intendi che k sarà più grande di log (N) per N piccola?

— Pavel Davydov,

k

$k$ e

N

$N$ sono parametri indipendenti, motivo per cui l'ordinamento radix non è un algoritmo a tempo lineare per tutti gli ingressi, e quindi non contraddice il

Ω (n \log n)

$\Omega(n \log n)$ legato all'ordinamento (confronto). (Anche l'articolo di Wikipedia lo spiega.)

— Raffaello

@Raphael Sì, ma per array di numeri interi che sono meno i 64 bit (è un caso abbastanza comune) sarà lineare. Modificherò la mia risposta. Grazie per i tuoi commenti

— Pavel Davydov,