Ordinamento rapido vs unione di unione rispetto

“L'obiettivo di questo articolo è quello di dare le somiglianze e le differenze tra ordinamento rapido e unione. L'articolo "Quick Ord in C", o un titolo simile, è già stato scritto per LinuxHint.com/. Il titolo può essere digitato nella casella di ricerca del Linuxhint.com home page per raggiungere l'articolo. Un altro articolo, "Merge Ording in C" o un titolo simile, è già stato scritto per LinuxHint.com/. Il titolo può essere digitato nella casella di ricerca del Linuxhint.com home page per raggiungere l'articolo. Si consiglia al lettore di riferirsi a quei due articoli mentre lui/lei legge questo.

L'ordinamento rapido è un algoritmo di smistamento. Unisci l'ordinamento è un altro algoritmo di smistamento. Il codice per i due articoli sopra menzionati è scritto in c. Il codice per questo articolo è anche scritto in C. Il lettore dovrebbe esserne consapevole. L'ordinamento ascendente è considerato per entrambi gli algoritmi di smistamento in questo articolo."

Contenuto dell'articolo

- Introduzione - Vedi sopra
- Algoritmi per ordinamento rapido e unione
- Big-O notazione di O (N), O (N2) e O (N.log (n))
- Confrontare l'ordinamento rapido e unire
- Conclusione

Algoritmi per ordinamento rapido e unione
Algoritmo per QuickSort

1) Se c'è solo uno o nessun elemento nell'elenco, restituisci. Un elemento significa che l'elenco è già ordinato. Elemento zero significa che non c'è nulla da ordinare.
2) Con un'ipotesi intelligente, scegli un elemento adatto nell'elenco come perno.
3) Partizione (dividi) l'elenco in tre sotto-listi. Rendi tutti gli elementi per la sotto-list di sinistra meno del perno. L'elenco centrale ha un solo elemento, che è il perno. Rendi tutti gli elementi sul sotto-list destro più grandi del perno. Mettendo elementi a sinistra che sono inferiori al perno e elementi a destra che sono maggiori del perno, senza puro ordinamento, che è già un po 'di smistamento (in senso lato).
4) Dividi ricorsivamente ogni sotto-list (sinistra e destra) in tre, come nella fase sopra, con ogni insieme di tre sotto-list che hanno il suo nuovo perno (di un elemento sotto-elenco), fino a quando l'intero elenco è perfettamente ordinato.

Esistono diversi moduli di codifica per il passaggio 2. Un modulo di codifica migliore porterà a un ordinamento completo più rapido.
Esistono diversi moduli di codifica per il passaggio 3. Un modulo di codifica migliore porterà a un ordinamento completo più rapido.

Algoritmo per Mergesort

1) Se c'è solo uno o nessun elemento nell'elenco, restituisci. Un elemento significa che l'elenco è già ordinato. Elemento zero significa che non c'è nulla da ordinare.
2) Dividi ricorsivamente l'elenco e le sue sotto-liste in due metà fino a quando ogni sotto-elenco ha un solo elemento.
3) Ordina coppie di sotto-list da sinistra a destra in modo ricorsivo, comprese coppie più grandi risultanti, fino a quando l'intero elenco non viene riacquistato ma completamente ordinato.

Questo è il modo normale di fare Mergesort e non dà davvero spazio, per diversi segmenti di codice, per lo stesso scopo di QuickSort.

Big-O notazione di O (N), O (N2) e O (N.log (n))

SU)
Considera il seguente codice:

int n = 8;
int sum = 0;
int a [] = 1, 2, 3, 4, 5, 6, 7, 8;
per (int i = 0; iSum = Sum + A [i];

printf ("%d \ n", somma);

n = 8. L'output, la somma è 36. Nel per anello, c'è un'operazione che viene eseguita 8 volte. Nella notazione Big-O, questa velocità (complessità del tempo) è scritta come,

SU)

Considera il seguente codice simile, in cui vengono aggiunti solo i numeri dispari:

int n = 8;
int sum = 0;
int a [] = 1, 2, 3, 4, 5, 6, 7, 8;
per (int i = 0; iSum = Sum + A [i];

printf ("%d \ n", somma);

L'output, somma questa volta, è 16. Nel per loop, l'unica operazione viene eseguita 4 volte, che è N/2 volte. Nella notazione Big-O, questa velocità (complessità del tempo) è ancora scritta come O (N). Il numero massimo di possibili operazioni è ciò che viene considerato.

SU²)

Considera il seguente codice che aggiunge la matrice di numeri 8 per 8:

int n = 8;
int sum = 0;
int a [] = 1, 2, 3, 4, 5, 6, 7, 8;
per (int i = 0; iper (int j = 0; jSum = Sum + A [J];


printf ("%d \ n", somma);

L'output, la somma, è 288. Nel loop per loop, c'è un'operazione che viene eseguita 8 x 8 volte = 64 volte. Nella notazione Big-O, questa velocità (complessità del tempo) è scritta come,

O (n²)

Considera il seguente codice simile, in cui vengono aggiunti solo i numeri dispari della matrice:

int n = 8;
int sum = 0;
int a [] = 1, 2, 3, 4, 5, 6, 7, 8;
per (int i = 0; iper (int j = 0; jSum = Sum + A [J];


printf ("%d \ n", somma);

L'output, somma questa volta, è 64. Nel per anello, l'unica operazione viene eseguita 4 x 4 volte = 16 volte, che è n²/4 volte. Questo è più di 8 volte (più di n volte) ma meno di 64 volte (meno di n² volte). Nella notazione Big-O, questa velocità (complessità del tempo) può ancora essere scritta come O (n²). Il numero massimo di possibili operazioni è ciò che viene considerato.

Qui, non confondere la somma, 64 e il numero di operazioni, 16. Questo caso di 16 operazioni, tra 8 (N) e 64 (N²), può ancora essere scritto, come nella seguente sottosezione.

SU.log (n))

Considera la situazione di una matrice 8 per 8, in cui il numero totale di operazioni è 24. 24 può essere visto come all'incirca nel mezzo, tra 8 (N) e 64 (N²).

Ora,

24 = 8xlog₂(8)
=> 24 = 8xlog₂(2³)
=> 24 = 8 × 3

Ora confronta,

24 = 8xlog₂(8)
con
24 = n.tronco d'albero₂(N)

Per il massimo di n², Quando il numero totale di operazioni è tra N e N², E intorno alla loro media, in notazione Big-O, questa velocità (complessità temporale) è meglio scritta come n.tronco d'albero₂(n) invece di O (n²).

Confrontare l'ordinamento rapido e unire
Numero di passaggi nell'algoritmo

Dall'alto, QuickSort ha 4 passaggi nel suo algoritmo, mentre Mergesort ha 3 passaggi nel suo algoritmo.

Diversi modi di codifica

L'ordinamento rapido ha diversi modi di codifica, mentre unione di unione ha solo un modo principale di codifica.

Complessità temporale

La complessità temporale per Mergesort è n.tronco d'albero₂(N). La sua velocità è paragonabile a quella della funzione di ordinamento della libreria C ++ utilizzata per scopi commerciali.

Quando la funzione di perno mediana viene utilizzata per QuickSort, la complessità del tempo è circa 1.188n.tronco d'albero₂(n), superiore a Mergesort, supponendo che venga utilizzata una buona funzione di partizione. Molti programmi QuickSort hanno una complessità temporale più elevata. La complessità del tempo peggiore per QuickSort è O (n²). Tuttavia, se il programma QuickSort è ben codificato con ottimi segmenti di codice, batterebbe Mergesort in velocità.

Conclusione

QuickSort normalmente funziona più lentamente di Mergesort.