Inleiding tot samenvoegen sorteren in Java

Programma voor Merge Sort in Java is een van de meest gebruikte en efficiënte algoritmen. Het samenvoegen is gebaseerd op verdeel en heers techniek waarbij een bepaald probleem in meerdere subproblemen wordt verdeeld en elk subprobleem onafhankelijk wordt opgelost. Wanneer de subproblemen zijn opgelost, combineren we de resultaten ervan om de definitieve oplossing voor het probleem te krijgen. Het sorteeralgoritme voor merge kan worden geïmplementeerd met behulp van recursie, omdat het werkt met subproblemen in plaats van het hoofdprobleem.

Hoe werkt het samenvoegen sorteren?

Laten we eens kijken naar een ongesorteerde array die moet worden gesorteerd met behulp van het samenvoeg sorteeralgoritme. Dit zijn de stappen voor het sorteren van een array met waarden: 18, 8, 4, 13, 10, 12, 7 en 11:

  • De eerste stap omvat het vinden van een scharnierelement op basis waarvan onze invoerarray zal worden verdeeld in subreeksen.
  • Laten we overwegen dat element 13 wordt gekozen als de spil, daarom zal de oorspronkelijke reeks worden verdeeld in twee subreeksen. De eerste subreeks zal 18, 8, 4, 13 bevatten en de tweede subreeks zal resterende elementen 10, 12, 7, 11 bevatten.
  • Subreeksen verkregen in stap 2 worden verder onderverdeeld zoals in stap 1 en dit gaat door.
  • Zodra de hoofdarray is verdeeld in subreeksen met afzonderlijke elementen, beginnen we deze subreeksen opnieuw samen te voegen zodat de samengevoegde elementen in gesorteerde volgorde staan.
  • Hier is hoe de werkelijke verdeel en heers werkt:

Programma voor Merge Sort in Java

Hier is een codevoorbeeld dat de implementatie van merge sort in Java toont:

Code:

package com.edubca.sorting;
public class MergeSort (
private int() array;
private int() tempMergedArr;
private int length;
public static void main(String a())(
int() inputArr = (18, 8, 4, 13, 10, 12, 7, 11);
MergeSort mergeSort = new MergeSort();
mergeSort.sort(inputArr);
for(int i:inputArr)(
System.out.print(i + " ");
)
)
public void sort(int inputArr()) (
this.array = inputArr;
this.length = inputArr.length;
this.tempMergedArr = new int(length);
performMergeSort(0, length - 1);
)
private void performMergeSort(int lowerIndex, int higherIndex) (
if (lowerIndex < higherIndex) (
int middle = lowerIndex + (higherIndex - lowerIndex) / 2;
// Sort the left side of the array call performMergeSort recursively
performMergeSort(lowerIndex, middle);
// Sort the right side of the array call performMergeSort recursively
performMergeSort(middle + 1, higherIndex);
// Merge subparts using a temporary array
mergeData(lowerIndex, middle, higherIndex);
)
)
private void mergeData (int lowerIndex, int middle, int higherIndex) (
for (int i = lowerIndex; i <= higherIndex; i++) (
tempMergedArr(i) = array(i);
)
int i = lowerIndex;
int j = middle + 1;
int k = lowerIndex;
while (i <= middle && j <= higherIndex) (
if (tempMergedArr(i) <= tempMergedArr(j)) (
array(k) = tempMergedArr(i);
i++;
) else (
array(k) = tempMergedArr(j);
j++;
)
k++;
)
while (i <= middle) (
array(k) = tempMergedArr(i);
k++;
i++;
)
)
)

De bovenstaande code produceert een gesorteerde array als uitvoer.

Output:

Wanneer moeten we de samenvoegsortering gebruiken?

Sorteren samenvoegen kan in de volgende scenario's worden gebruikt:

  • Wanneer de te sorteren gegevensstructuur geen willekeurige toegang ondersteunt, kan het samenvoegen sorteren nuttig en efficiënt zijn.
  • Wanneer een hoog niveau van parallellisme vereist is, kan samenvoegen worden gebruikt omdat verschillende subproblemen onafhankelijk van elkaar kunnen worden opgelost met behulp van meerdere processen die parallel lopen.
  • Het sorteren samenvoegen gaat sneller wanneer u met gekoppelde lijsten werkt, omdat verwijzingen gemakkelijk kunnen worden gewijzigd tijdens het samenvoegen van de lijsten.
  • Sorteren samenvoegen kan worden beschouwd als een stabiele sortering, wat betekent dat hetzelfde element in een array hun oorspronkelijke posities ten opzichte van elkaar behoudt. In gevallen waar hoge stabiliteit vereist is, kan men kiezen voor samenvoegen.

Complexiteitsanalyse van samenvoegsortering

Hieronder punten analyse complexiteit van samenvoeging sorteren:

  • Samenvoegsortering is een recursief algoritme en de tijdcomplexiteit is O (n * log n) in alle drie de gevallen (slechtste, beste en gemiddelde), omdat samenvoegsortering de array in twee gelijke helften verdeelt en lineaire tijd nodig heeft om ze samen te voegen.
  • Ruimtecomplexiteit van samenvoegsoorten is O (n) omdat deze werkt op de recursieve benadering. Daarom kan het samenvoegen worden beschouwd als een snel, ruimte- en tijdbesparend algoritme.

Sorteren vergelijken met andere algoritmen

Onderstaande punten vergelijken het samenvoegen met andere algoritmen:

  • Heap Sort heeft dezelfde tijdcomplexiteit als merge sort, maar het vereist alleen O (1) hulpruimte in plaats van O (n) van merge sort. Heap-sortering is dus ruimtebesparend dan merge-sortering.
  • Quick Sort-implementaties presteren over het algemeen beter dan merge-sortering voor het sorteren van RAM-gebaseerde arrays.
  • Samenvoegen sorteert beter dan snelle sorteer- en heap-sorteeralgoritmen bij het werken met de gekoppelde lijst, omdat aanwijzers gemakkelijk kunnen worden gewijzigd.

Conclusie-programma voor Merge Sort in Java

Uit het artikel wordt geconcludeerd dat het samenvoegen een belangrijk concept is om te begrijpen als het gaat om algoritmen.

Aanbevolen artikelen

Dit is een gids voor Program for Merge Sort in Java. Hier bespreken we hoe het moet werken, het gebruik, het programma van Merge Sort, enz. U kunt ook onze andere gerelateerde artikelen lezen voor meer informatie-

  1. Sorteren samenvoegen in Java
  2. Sorteeralgoritmen in Java samenvoegen
  3. Heap Sorteer in C
  4. Heap Sort In Java
  5. Hulpmiddelen voor Java-implementatie
  6. Heap Sort in Python
  7. Snel sorteren algoritmen in Java
  8. Top 6 sorteeralgoritme in JavaScript
  9. Top 6 Sorteeralgoritmen in Python

Categorie:

Software ontwikkeling