Introduzione a Merge Sort in Java
Unisci ordinamento in Java è uno dei metodi di ordinamento. L'ordinamento in qualsiasi linguaggio di programmazione significa disporre i dati in modo sequenziale. La disposizione potrebbe essere in ordine crescente o in ordine decrescente. Dipende completamente dall'utente su ciò che desidera che l'ordine sia. L'ordinamento viene utilizzato non solo per i numeri, ma anche nel caso di alfabeti e nomi. L'ordinamento viene utilizzato per assegnare numeri di tiri agli studenti di una classe. Inoltre, alla persona che arriva per prima viene assegnato il Rango 1 secondo l'algoritmo di ordinamento. L'ordinamento può essere applicato a rango, peso, altezza e persino ai nomi delle rispettive persone in generale. Esistono molte tecniche di ordinamento in Java che sono ampiamente utilizzate da programmatori e programmatori per garantire che tutti i modi possibili di organizzare i dati siano curati.
Alcune delle tecniche popolari utilizzate in Java per l'algoritmo di ordinamento sono descritte di seguito
- Ordinamento delle bolle
- Ordinamento di selezione
- Ordinamento per inserzione
- Ordinamento dell'heap
- Unisci ordinamento
Oltre alle tecniche sopra menzionate, ci sono anche altre tecniche che possono essere utilizzate per ordinare i dati in sequenza come Quicksort.
Funzionamento di Merge Sort In Java
In Merge Sort in Java, vedremo il funzionamento del meccanismo Merge Sort inventato da John Von Neumann nell'anno 1945 che viene utilizzato in Java allo scopo di organizzare sequenzialmente i dati. Unisci ordinamento in Java è abbastanza simile al meccanismo di ordinamento rapido. Viene anche chiamato algoritmo Divide and Conquer. In parole semplici, divide l'array in due metà. Successivamente, ordina i due array in un rispettivo ordine come desiderato dall'utente. Quindi, infine, unisce le due metà e diventa facilmente un singolo array ordinato completo. Supponiamo ora che esista un array chiamato arr (). Unisci il meccanismo di ordinamento divide prima l'array in due metà uguali. Quindi ordina le rispettive metà ottenendo un array ordinato su ciascuna estremità. Infine, le due metà vengono eguagliate anche se l'indice sinistro è maggiore di quello destro o viceversa e quindi il numero viene inserito nell'array. In questo modo, l'array viene ordinato.
Il diagramma seguente mostra come viene ordinato un array utilizzando l'ordinamento di tipo merge. 
Esempio 1
Nel primo esempio, vedremo una serie di numeri ordinati in un array. I numeri sono i più facili da ordinare in quanto non vi sono valori ASCII associati ai numeri come nel caso di alfabeti o nomi. Il seguente programma mostra l'ordinamento in modo da ordinare i numeri di ordinamento in ordine crescente. Esistono due matrici, ovvero la matrice sinistra e la matrice destra. L'array ha 10 numeri che sono stati disposti in ordine crescente, cioè dal più piccolo al più grande.
Codice
public class MyMergeSort
(
void merge(int arr(), int beg, int mid, int end)
(
intl = mid - beg + 1;
intr = end - mid;
intLeftArray() = newint (l);
intRightArray() = newint(r);
for(inti=0; i LeftArray(i) = arr(beg + i);
for(intj=0; j RightArray(j) = arr(mid + 1+ j);
inti = 0, j = 0;
intk = beg;
while(i (
if(LeftArray(i) <= RightArray(j))
(
arr(k) = LeftArray(i);
i++;
)
else
(
arr(k) = RightArray(j);
j++;
)
k++;
)
while(i (
arr(k) = LeftArray(i);
i++;
k++;
)
while(j (
arr(k) = RightArray(j);
j++;
k++;
)
)
voidsort(intarr(), int beg, int end)
(
if(beg (
intmid = (beg+end)/2;
sort(arr, beg, mid);
sort(arr, mid+1, end);
merge(arr, beg, mid, end);
)
)
publicstaticvoid main(String args())
(
intarr() = (90, 23, 101, 45, 65, 23, 67, 89, 34, 23);
MyMergeSort ob = newMyMergeSort();
sort(arr, 0, arr.length-1);
out.println("\nSorted array");
for(inti =0; i (
out.println(arr(i)+"");
)
)
)public class MyMergeSort
(
void merge(int arr(), int beg, int mid, int end)
(
intl = mid - beg + 1;
intr = end - mid;
intLeftArray() = newint (l);
intRightArray() = newint(r);
for(inti=0; i LeftArray(i) = arr(beg + i);
for(intj=0; j RightArray(j) = arr(mid + 1+ j);
inti = 0, j = 0;
intk = beg;
while(i (
if(LeftArray(i) <= RightArray(j))
(
arr(k) = LeftArray(i);
i++;
)
else
(
arr(k) = RightArray(j);
j++;
)
k++;
)
while(i (
arr(k) = LeftArray(i);
i++;
k++;
)
while(j (
arr(k) = RightArray(j);
j++;
k++;
)
)
voidsort(intarr(), int beg, int end)
(
if(beg (
intmid = (beg+end)/2;
sort(arr, beg, mid);
sort(arr, mid+1, end);
merge(arr, beg, mid, end);
)
)
publicstaticvoid main(String args())
(
intarr() = (90, 23, 101, 45, 65, 23, 67, 89, 34, 23);
MyMergeSort ob = newMyMergeSort();
sort(arr, 0, arr.length-1);
out.println("\nSorted array");
for(inti =0; i (
out.println(arr(i)+"");
)
)
)public class MyMergeSort
(
void merge(int arr(), int beg, int mid, int end)
(
intl = mid - beg + 1;
intr = end - mid;
intLeftArray() = newint (l);
intRightArray() = newint(r);
for(inti=0; i LeftArray(i) = arr(beg + i);
for(intj=0; j RightArray(j) = arr(mid + 1+ j);
inti = 0, j = 0;
intk = beg;
while(i (
if(LeftArray(i) <= RightArray(j))
(
arr(k) = LeftArray(i);
i++;
)
else
(
arr(k) = RightArray(j);
j++;
)
k++;
)
while(i (
arr(k) = LeftArray(i);
i++;
k++;
)
while(j (
arr(k) = RightArray(j);
j++;
k++;
)
)
voidsort(intarr(), int beg, int end)
(
if(beg (
intmid = (beg+end)/2;
sort(arr, beg, mid);
sort(arr, mid+1, end);
merge(arr, beg, mid, end);
)
)
publicstaticvoid main(String args())
(
intarr() = (90, 23, 101, 45, 65, 23, 67, 89, 34, 23);
MyMergeSort ob = newMyMergeSort();
sort(arr, 0, arr.length-1);
out.println("\nSorted array");
for(inti =0; i (
out.println(arr(i)+"");
)
)
)public class MyMergeSort
(
void merge(int arr(), int beg, int mid, int end)
(
intl = mid - beg + 1;
intr = end - mid;
intLeftArray() = newint (l);
intRightArray() = newint(r);
for(inti=0; i LeftArray(i) = arr(beg + i);
for(intj=0; j RightArray(j) = arr(mid + 1+ j);
inti = 0, j = 0;
intk = beg;
while(i (
if(LeftArray(i) <= RightArray(j))
(
arr(k) = LeftArray(i);
i++;
)
else
(
arr(k) = RightArray(j);
j++;
)
k++;
)
while(i (
arr(k) = LeftArray(i);
i++;
k++;
)
while(j (
arr(k) = RightArray(j);
j++;
k++;
)
)
voidsort(intarr(), int beg, int end)
(
if(beg (
intmid = (beg+end)/2;
sort(arr, beg, mid);
sort(arr, mid+1, end);
merge(arr, beg, mid, end);
)
)
publicstaticvoid main(String args())
(
intarr() = (90, 23, 101, 45, 65, 23, 67, 89, 34, 23);
MyMergeSort ob = newMyMergeSort();
sort(arr, 0, arr.length-1);
out.println("\nSorted array");
for(inti =0; i (
out.println(arr(i)+"");
)
)
)public class MyMergeSort
(
void merge(int arr(), int beg, int mid, int end)
(
intl = mid - beg + 1;
intr = end - mid;
intLeftArray() = newint (l);
intRightArray() = newint(r);
for(inti=0; i LeftArray(i) = arr(beg + i);
for(intj=0; j RightArray(j) = arr(mid + 1+ j);
inti = 0, j = 0;
intk = beg;
while(i (
if(LeftArray(i) <= RightArray(j))
(
arr(k) = LeftArray(i);
i++;
)
else
(
arr(k) = RightArray(j);
j++;
)
k++;
)
while(i (
arr(k) = LeftArray(i);
i++;
k++;
)
while(j (
arr(k) = RightArray(j);
j++;
k++;
)
)
voidsort(intarr(), int beg, int end)
(
if(beg (
intmid = (beg+end)/2;
sort(arr, beg, mid);
sort(arr, mid+1, end);
merge(arr, beg, mid, end);
)
)
publicstaticvoid main(String args())
(
intarr() = (90, 23, 101, 45, 65, 23, 67, 89, 34, 23);
MyMergeSort ob = newMyMergeSort();
sort(arr, 0, arr.length-1);
out.println("\nSorted array");
for(inti =0; i (
out.println(arr(i)+"");
)
)
)public class MyMergeSort
(
void merge(int arr(), int beg, int mid, int end)
(
intl = mid - beg + 1;
intr = end - mid;
intLeftArray() = newint (l);
intRightArray() = newint(r);
for(inti=0; i LeftArray(i) = arr(beg + i);
for(intj=0; j RightArray(j) = arr(mid + 1+ j);
inti = 0, j = 0;
intk = beg;
while(i (
if(LeftArray(i) <= RightArray(j))
(
arr(k) = LeftArray(i);
i++;
)
else
(
arr(k) = RightArray(j);
j++;
)
k++;
)
while(i (
arr(k) = LeftArray(i);
i++;
k++;
)
while(j (
arr(k) = RightArray(j);
j++;
k++;
)
)
voidsort(intarr(), int beg, int end)
(
if(beg (
intmid = (beg+end)/2;
sort(arr, beg, mid);
sort(arr, mid+1, end);
merge(arr, beg, mid, end);
)
)
publicstaticvoid main(String args())
(
intarr() = (90, 23, 101, 45, 65, 23, 67, 89, 34, 23);
MyMergeSort ob = newMyMergeSort();
sort(arr, 0, arr.length-1);
out.println("\nSorted array");
for(inti =0; i (
out.println(arr(i)+"");
)
)
)public class MyMergeSort
(
void merge(int arr(), int beg, int mid, int end)
(
intl = mid - beg + 1;
intr = end - mid;
intLeftArray() = newint (l);
intRightArray() = newint(r);
for(inti=0; i LeftArray(i) = arr(beg + i);
for(intj=0; j RightArray(j) = arr(mid + 1+ j);
inti = 0, j = 0;
intk = beg;
while(i (
if(LeftArray(i) <= RightArray(j))
(
arr(k) = LeftArray(i);
i++;
)
else
(
arr(k) = RightArray(j);
j++;
)
k++;
)
while(i (
arr(k) = LeftArray(i);
i++;
k++;
)
while(j (
arr(k) = RightArray(j);
j++;
k++;
)
)
voidsort(intarr(), int beg, int end)
(
if(beg (
intmid = (beg+end)/2;
sort(arr, beg, mid);
sort(arr, mid+1, end);
merge(arr, beg, mid, end);
)
)
publicstaticvoid main(String args())
(
intarr() = (90, 23, 101, 45, 65, 23, 67, 89, 34, 23);
MyMergeSort ob = newMyMergeSort();
sort(arr, 0, arr.length-1);
out.println("\nSorted array");
for(inti =0; i (
out.println(arr(i)+"");
)
)
)public class MyMergeSort
(
void merge(int arr(), int beg, int mid, int end)
(
intl = mid - beg + 1;
intr = end - mid;
intLeftArray() = newint (l);
intRightArray() = newint(r);
for(inti=0; i LeftArray(i) = arr(beg + i);
for(intj=0; j RightArray(j) = arr(mid + 1+ j);
inti = 0, j = 0;
intk = beg;
while(i (
if(LeftArray(i) <= RightArray(j))
(
arr(k) = LeftArray(i);
i++;
)
else
(
arr(k) = RightArray(j);
j++;
)
k++;
)
while(i (
arr(k) = LeftArray(i);
i++;
k++;
)
while(j (
arr(k) = RightArray(j);
j++;
k++;
)
)
voidsort(intarr(), int beg, int end)
(
if(beg (
intmid = (beg+end)/2;
sort(arr, beg, mid);
sort(arr, mid+1, end);
merge(arr, beg, mid, end);
)
)
publicstaticvoid main(String args())
(
intarr() = (90, 23, 101, 45, 65, 23, 67, 89, 34, 23);
MyMergeSort ob = newMyMergeSort();
sort(arr, 0, arr.length-1);
out.println("\nSorted array");
for(inti =0; i (
out.println(arr(i)+"");
)
)
)
Inoltre, l'output di esempio è mostrato di seguito. Il codice viene eseguito utilizzando la piattaforma Blue J che genera senza problemi l'array ordinato in ordine crescente.
Produzione
Esempio 2
Nel secondo esempio, li vedremo lavorare su come alfabeti o nomi o ordinati utilizzando la tecnica di ordinamento Merge in Java. Nel seguente programma, prendiamo i nomi delle persone in qualsiasi ordine casuale. Il singolo mergeSort () prima ordina i nomi in ordine alfabetico. In secondo luogo, LeftMergeSort () e RightMergeSort () vengono confrontati per vedere quale nome sarebbe alfabeticamente precedente o successivo.
Codice
import java.util.*;
public class NewClass (
public static void main(String() args) (
String() OneGo = ( "Kring", "Panda", "Soliel", "Darryl", "Chan", "Matang", "Jollibee.", "Inasal" );
String() TwoGo = ( "Minnie", "Kitty", "Madonna", "Miley", "Zoom-zoom", "Cristine", "Bubbles", "Ara", "Rose", "Maria" );
String() nameGo = new String(OneGo.length + TwoGo.length);
mergeSort(OneGo);
mergeSort(TwoGo);
merge(nameGo, OneGo, TwoGo);
mergeSort(nameGo);
//Arrays.sort(names);
for (String ClassThree: nameGo) (
System.out.println(ClassThree);
)
)
public static void mergeSort(String() nameGo) (
if (nameGo.length > 1) (
String() leftGo = new String(nameGo.length / 2);
String() rightGo = new String(nameGo.length - nameGo.length / 2);
for (int so = 0; so < leftGo.length; so++) (
leftGo(so) = nameGo(so);
)
for (int ki = 0; ki < rightGo.length; ki++) (
rightGo(ki) = nameGo(ki + nameGo.length / 2);
)
mergeSort(leftGo);
mergeSort(rightGo);
merge(nameGo, leftGo, rightGo);
)
)
public static void merge(String() nameH, String() leftH, String() rightH) (
int as = 0;
int bs = 0;
for (int i = 0; i < nameH.length; i++) (
if (bs >= rightH.length || (as < leftH.length && leftH(as).compareToIgnoreCase(rightH(bs)) < 0)) (
nameH(i) = leftH(as);
as++;
) else (
nameH(i) = rightH(bs);
bs++;
)
)
)
)
Di seguito viene mostrato anche l'output di esempio in questo programma che ordina i nomi in ordine alfabetico.
Produzione
Conclusione
Nell'articolo, vediamo come funziona l'ordinamento unito e ordina i numeri e i nomi in ordine alfabetico. Unisci ordinamento è molto simile all'ordinamento rapido. Unire l'ordinamento è relativamente facile da usare rispetto ad altre tecniche di ordinamento. È diverso dall'ordinamento Selection che confronta ogni singolo elemento tra loro. L'ordinamento di tipo merge viene utilizzato in Java, C, C ++, Python e molti altri linguaggi di programmazione per i suoi svariati vantaggi. È utilizzato nelle società FMCG in cui i prodotti hanno etichette e numeri diversi assegnati, nelle società di telecomunicazioni, nelle industrie manifatturiere e chimiche. È una tecnica di smistamento molto famosa a causa del suo uso variabile in numerosi luoghi.
Articolo raccomandato
Questa è stata una guida per unire l'ordinamento in Java. Qui discutiamo un'introduzione a Merge Sort it lavorando insieme all'esempio. Puoi anche consultare i nostri altri articoli suggeriti per saperne di più -
- Strumenti Java
- Strutture in Java
- Distruttore in Java
- Guida per unire l'ordinamento in JavaScript
- Ordinamento dell'heap in Python
- Inserimento Ordina in JavaScript