Inleiding tot snelle sorteeralgoritmen in Java

Snel sorteren in Java ook bekend als de partitie-uitwisselingssortering is een verdeel en heers sorteeralgoritme. Snel sorteren is een goed voorbeeld van een algoritme dat het beste gebruik maakt van CPU-caches, vanwege de kloof en overwint aard. Quicksort-algoritme is een van de meest gebruikte sorteeralgoritmen, vooral om de grote lijsten te sorteren en de meeste programmeertalen hebben het geïmplementeerd. In het Quicksort-algoritme worden de oorspronkelijke gegevens verdeeld in twee delen die afzonderlijk worden gesorteerd en vervolgens worden samengevoegd om gesorteerde gegevens te produceren.

Laten we overwegen dat de array (8, 6, 3, 4, 9, 2, 1, 7) moet worden gesorteerd met behulp van Snel sorteren.

Stappen om snel sorteren algoritmen te implementeren

1. Kies een element met de naam pivot uit de array. Over het algemeen wordt het middelste element gekozen als de spil. Laten we 4 nemen als de spil.

2. Herschik de array in twee delen zodat elementen die kleiner zijn dan de pivot vóór de pivot komen en elementen groter dan de pivot na de pivot verschijnen. Volgende stappen worden gevolgd:

  • Kies het meest linkse element, dat wil zeggen 8, aangezien 4 de spil is en 8 meer dan 4 is, moet 8 naar rechts van 4 worden verplaatst, aan de rechterkant laten we 7 omdat het groter is dan 4 en kies 1 voor ruilen met 8 wordt de reeks dus na omwisseling: 1, 6, 3, 4, 9, 2, 8, 7
  • Kies het volgende linker element, dwz 6, aangezien 4 de spil is en 6 meer dan 4 is, moet 6 naar rechts van 4 worden verplaatst, aan de rechterkant laten we 7, 8 achter omdat ze groter zijn dan 4 en kiezen 2 voor ruilen met 6 dus na ruilen wordt de reeks: 1, 2, 3, 4, 9, 6, 8, 7
  • Omdat alle elementen links van de pivot kleiner zijn dan de pivot en alle elementen rechts van de pivot groter zijn dan de pivot, zijn we klaar met 4 als pivot.

3. Pas stap 1 en 2 recursief toe voor de linker subarray (array met elementen kleiner dan de pivot) en voor de rechter subarray (array met elementen meer dan de pivot). Als de array slechts één of nul elementen bevat, wordt de array als geassorteerd beschouwd.

Programma om snel sorterende algoritmen te implementeren

Hier is een Java-programma om een ​​reeks gehele getallen te sorteren met behulp van een snel sorteeralgoritme.

Code:

import java.lang.*;
import java.util.*;
public class Main (
private int array();
private int length;
public void sort(int() inputArrayArr) (
if (inputArrayArr == null || inputArrayArr.length == 0) (
return;
)
this.array = inputArrayArr;
length = inputArrayArr.length;
performQuickSort(0, length - 1);
)
private void performQuickSort(int lowerIndex, int higherIndex) (
int i = lowerIndex;
int j = higherIndex;
// calculate pivot number
// middle element taken as pivot
int pivot = array(lowerIndex+(higherIndex-lowerIndex)/2);
// Divide into two subarrays
while (i <= j) (
/**
* In each iteration, find an element from left side of the pivot which
* is greater than the pivot value, and also find an element
* From right side of the pivot which is less than the pivot value. Once the search
* is complete, we exchange both elements.
*/
while (array(i) < pivot) (
i++;
)
while (array(j) > pivot) (
j--;
)
if (i <= j) (
swapNumbers(i, j);
//move index to next position on both sides
i++;
j--;
)
)
// call performQuickSort() method recursively
if (lowerIndex < j)
performQuickSort(lowerIndex, j);
if (i < higherIndex)
performQuickSort(i, higherIndex);
)
private void swapNumbers(int i, int j) (
int temp = array(i);
array(i) = array(j);
array(j) = temp;
)
public static void main(String args())(
Main quickSort = new Main();
int() inputArray = (8, 6, 3, 4, 9, 2, 1, 7);
quickSort.sort(inputArray);
System.out.println("Sorted Array " + Arrays.toString(inputArray));
)
)

Output:

Voordelen van Quick Sorting Algorithms

Dit zijn de voordelen van het snelle sorteeralgoritme:

  • Uitstekende referentielocatie: de referentielocatie is het vermogen van een processor om herhaaldelijk gedurende korte tijd toegang te krijgen tot dezelfde geheugenlocatie. Snel sorteren in Java biedt een uitstekende plaats van referentie vanwege het zeer kleine aantal cache-missers, wat op moderne architecturen cruciaal is voor de prestaties.
  • Snel sorteren is parallel: zodra de eerste stap van het partitioneren van een array in kleinere gebieden is voltooid, kunnen alle afzonderlijke subreeksen onafhankelijk van elkaar parallel worden gesorteerd. Vanwege deze reden presteert snel sorteren beter.

Complexiteitsanalyse van Quick Sort

Quicksort is een snel en staartrecursief algoritme dat werkt volgens het verdeel en heers principe. Hier is de complexiteitsanalyse in Best, Average en Worst Case:

  • Best Case Complexity: als een array of een lijst n elementen bevat, heeft de eerste run O (n) nodig. Het sorteren van de resterende twee subreeksen duurt nu 2 * O (n / 2). Dit concludeert in het beste geval de complexiteit van O (n logn).
  • Gemiddelde case-complexiteit: De gemiddelde case van quicksort is O (n log n).
  • Worst Case Complexity: Als u voor het eerste of het laatste kiest, levert dit de slechtste case-prestaties op voor bijna gesorteerde of bijna omgekeerde gesorteerde gegevens. Snel sorteren voert O (n 2) uit in het slechtste geval.

In Java, arrays. De methode Sort () gebruikt een snel sorteeralgoritme om een ​​array te sorteren.

Aanbevolen artikelen

Dit is een handleiding voor snelle sorteeralgoritmen in Java. Hier bespreken we de te implementeren stappen, voordelen en complexiteitsanalyse van een snel sorteeralgoritme in Java samen met het programma. U kunt ook de volgende artikelen bekijken voor meer informatie -

  1. Invoegsortering in Java
  2. do-while-lus in Java
  3. JComponent in Java
  4. Vierkanten op Java
  5. Ruilen in PHP
  6. Sorteren in C #
  7. Sorteren in Python
  8. C ++ Algoritme | Voorbeelden van C ++ algoritme

Categorie:

Software ontwikkeling