quicksort java algorithm
Questo tutorial spiega l'algoritmo Quicksort in Java, le sue illustrazioni, l'implementazione di QuickSort in Java con l'aiuto di esempi di codice:
La tecnica di ordinamento Quicksort è ampiamente utilizzata nelle applicazioni software. Quicksort utilizza una strategia divide et impera come l'ordinamento di unione.
Nell'algoritmo quicksort, viene prima selezionato un elemento speciale chiamato 'pivot' e l'array o l'elenco in questione viene partizionato in due sottoinsiemi. I sottoinsiemi partizionati possono o meno avere le stesse dimensioni.
=> Leggere attraverso la serie di formazione Easy Java.
Le partizioni sono tali che tutti gli elementi inferiori all'elemento pivot siano verso la sinistra del pivot e gli elementi maggiori del pivot siano a destra del pivot. La routine Quicksort ordina ricorsivamente i due elenchi secondari. Quicksort funziona in modo efficiente e anche più veloce anche per array o elenchi più grandi.
Cosa imparerai:
- Quicksort Partition Java
- Algoritmo Quicksort Java
- Pseudocodice per ordinamento rapido
- Illustrazione
- Implementazione di Quicksort in Java
- Domande frequenti
- Conclusione
- Lettura consigliata
Quicksort Partition Java
Il partizionamento è il processo chiave della tecnica Quicksort. Allora, cos'è il partizionamento?
Dato un array A, scegliamo un valore x chiamato pivot tale che tutti gli elementi minori di x siano prima di x, e tutti gli elementi maggiori di x siano dopo x.
Un valore pivot può essere uno dei seguenti:
- Il primo elemento dell'array
- L'ultimo elemento dell'array
- L'elemento medio dell'array
- Qualsiasi elemento casuale nella matrice
Questo valore pivot viene quindi posizionato nella posizione corretta nell'array partizionando l'array. Pertanto, l'output del processo di 'partizionamento' è il valore pivot nella sua posizione corretta e gli elementi minori di pivot a sinistra e gli elementi maggiori di un pivot a destra.
Considera il seguente diagramma che spiega il processo di partizionamento.
curriculum di esempio per tester software esperti
Il diagramma sopra mostra il processo di partizionamento dell'array selezionando ripetutamente l'ultimo elemento dell'array come pivot. Ad ogni livello, nota che partizioniamo l'array in due sotto-array posizionando il pivot nella sua posizione corretta.
Successivamente, elenchiamo l'algoritmo e lo pseudo-codice per la tecnica quicksort che include anche la routine di partizione.
Algoritmo Quicksort Java
Di seguito viene fornito l'algoritmo generale per Quicksort.
quicksort(Arr, low, high) begin Declare array Arr(N) to be sorted low = 1st element; high = last element; pivot if(low Di seguito è riportato lo pseudo codice per la tecnica quicksort.
miglior downloader mp3 gratuito per Android
Pseudocodice per ordinamento rapido
Di seguito è riportato lo pseudo codice per una tecnica di ordinamento rapida. Nota che abbiamo fornito lo pseudo-codice per quicksort e routine di partizionamento.
//pseudocode for quick sort main algorithm procedure quickSort(arr(), low, high) arr = list to be sorted low – first element of the array high – last element of array begin if (low Illustrazione
Vediamo l'illustrazione dell'algoritmo quicksort. Prendi il seguente array come esempio. Qui abbiamo selezionato l'ultimo elemento come pivot.
Come mostrato, il primo elemento è etichettato come basso e l'ultimo elemento è alto.
Come evidente nell'illustrazione sopra, ci sono due puntatori, alto e basso che puntano rispettivamente all'ultimo e al primo elemento della matrice. Entrambi questi puntatori vengono spostati man mano che il quicksort procede.
Quando l'elemento puntato dal puntatore basso diventa maggiore dell'elemento perno e l'elemento puntato dal puntatore alto è minore dell'elemento perno, scambiamo gli elementi puntati dal puntatore basso e alto e ogni puntatore avanza di 1 posizione.
I passaggi precedenti vengono eseguiti fino a quando entrambi i puntatori si incrociano nell'array. Una volta che si incrociano, l'elemento pivot ottiene la posizione corretta nell'array. A questo punto, l'array è partizionato e ora possiamo ordinare ogni sotto-array in modo indipendente applicando ricorsivamente un algoritmo di ordinamento rapido a ciascuno degli array.
Implementazione di Quicksort in Java
La tecnica QuickSort può essere implementata in Java utilizzando la ricorsione o l'iterazione. In questa sezione vedremo entrambe queste tecniche.
Quicksort ricorsivo
Sappiamo che la tecnica di base del quicksort illustrata sopra utilizza la ricorsione per ordinare l'array. Nel quicksort ricorsivo dopo aver partizionato l'array, la routine quicksort viene chiamata ricorsivamente per ordinare i sotto-array.
L'implementazione seguente mostra la tecnica del quicksort usando la ricorsione.
import java.util.*; class QuickSort { //selects last element as pivot, pi using which array is partitioned. int partition(int intArray(), int low, int high) { int pi = intArray(high); int i = (low-1); // smaller element index for (int j=low; j Produzione:
Serie originale: (4, -1, 6, 8, 0, 5, -3)
Array ordinato: (-3, -1, 0, 4, 5, 6, 8)
Quicksort iterativo
In quicksort iterativo, usiamo lo stack ausiliario per posizionare parametri intermedi invece di usare la ricorsione e le partizioni di ordinamento.
Il seguente programma Java implementa quicksort iterativo.
import java.util.*; class Main { //partitions the array around pivot=> last element static int partition(int numArray(), int low, int high) { int pivot = numArray(high); // smaller element index int i = (low - 1); for (int j = low; j <= high - 1; j++) { // check if current element is less than or equal to pivot if (numArray(j) <= pivot) { i++; // swap the elements int temp = numArray(i); numArray(i) = numArray(j); numArray(j) = temp; } } // swap numArray(i+1) and numArray(high) (or pivot) int temp = numArray(i + 1); numArray(i + 1) = numArray(high); numArray(high) = temp; return i + 1; } //sort the array using quickSort static void quickSort(int numArray(), int low, int high) { //auxillary stack int() intStack = new int(high - low + 1); // top of stack initialized to -1 int top = -1; // push initial values of low and high to stack intStack(++top) = low; intStack(++top) = high; // Keep popping from stack while is not empty while (top>= 0) { // Pop h and l high = intStack(top--); low = intStack(top--); // Set pivot element at its correct position // in sorted array int pivot = partition(numArray, low, high); // If there are elements on left side of pivot, // then push left side to stack if (pivot - 1 > low) { intStack(++top) = low; intStack(++top) = pivot - 1; } // If there are elements on right side of pivot, // then push right side to stack if (pivot + 1 Produzione:
Serie originale: (3, 2, 6, -1, 9, 1, -6, 10, 5)
Serie ordinata: (- 6, -1, 1, 2, 3, 6, 9, 10, 5)
cos'è un test case nel test del software con l'esempio
Domande frequenti
Q # 1) Come funziona un Quicksort?
Risposta: Quicksort utilizza una strategia divide et impera. Quicksort partiziona dapprima un array attorno a un elemento pivot selezionato e genera sotto-array ordinati in modo ricorsivo.
D # 2) Qual è la complessità temporale di Quicksort?
Risposta: La complessità temporale di quicksort in media è O (nlogn). Nel peggiore dei casi, è O (n ^ 2) uguale all'ordinamento di selezione.
D # 3) Dove viene utilizzato Quicksort?
Risposta: Quicksort è utilizzato principalmente nelle applicazioni ricorsive. Quicksort è la parte della libreria C. Inoltre, quasi i linguaggi di programmazione che utilizzano l'ordinamento integrato implementano Quicksort.
Q # 4) Qual è il vantaggio di Quicksort?
Risposta:
- Quicksort è un algoritmo efficiente e può facilmente ordinare anche un enorme elenco di elementi.
- È un ordinamento sul posto e quindi non necessita di spazio o memoria aggiuntivi.
- È ampiamente utilizzato e fornisce un modo efficiente per ordinare set di dati di qualsiasi lunghezza.
D # 5) Perché Quicksort è migliore del merge sort?
Risposta: Il motivo principale per cui il quicksort è migliore del merge sort è che quicksort è un metodo di ordinamento sul posto e non richiede spazio di memoria aggiuntivo. L'ordinamento di unione richiede memoria aggiuntiva per l'ordinamento intermedio.
Conclusione
Quicksort è considerato il miglior algoritmo di ordinamento principalmente per la sua efficienza nel ordinare anche un enorme set di dati in tempo O (nlogn).
Quicksort è anche un ordinamento sul posto e non richiede spazio di memoria aggiuntivo. In questo tutorial, abbiamo visto l'implementazione ricorsiva e iterativa di quicksort.
Nel nostro prossimo tutorial, continueremo con i metodi di ordinamento in Java.
=> Dai un'occhiata alla guida per principianti di Java qui.
Lettura consigliata
- Algoritmo di ricerca binaria in Java - implementazione ed esempi
- Java Array - Come stampare elementi di un array in Java?
- Ordina selezione in Java - Algoritmo di ordinamento selezione ed esempi
- Tipi di dati array: int Array, Double array, Array of Strings Etc.
- Array Java: dichiara, crea e inizializza un array in Java
- Tutorial JAVA per principianti: oltre 100 tutorial video Java pratici
- Java Copy Array: come copiare / clonare un array in Java
- Tutorial sulla lunghezza di array Java con esempi di codice
