Introduksjon til flette sorteringsalgoritmer i Java
Sammenslåingssorteringsalgoritmer er veldig viktige innen informatikk. Resultatet av sorteringen er å ordne elementene i en liste i en viss rekkefølge (enten stigende eller synkende). Merge sort er en av de mest effektive sorteringsalgoritmene som er tilgjengelige, fordi den er basert på begrepet splitt og erobrere. Som navnet antyder, del først det større problemet i små problemer enn å løse de mindre problemene for å løse det større problemet. I denne artikkelen skal vi diskutere flette sorteringsalgoritmer i Java. Konseptuelt er Merge sort en kombinasjon av to grunnleggende algoritmer kalt MERGE og MERGE_SORT som fungerer som følger:
- Del den usorterte listen i n antall undelister med ett element (n er det totale antall elementer i den usorterte listen).
- Flett sublistene gjentatte ganger til sorterte sublister til det bare er en sortert liste.
Implementering av flette sorteringsalgoritmer i Java
MERGE-algoritmen er fremgangsmåten for å kombinere to sorterte lister til en sortert liste.
Eksempel: Anta at det er to lister, dvs. liste 1 (6, 3) og liste 2 (3, 1, 9).
1. Sorter først begge listene.
Liste 1
Liste 2
Nå vil vi bruke en sammenslåingsteknikk på den.
- Deretter vil vi opprette en ny liste over størrelse m + n der m er antall elementer i liste 1 og n er antall elementer i liste 2.
Liste 3
I vårt tilfelle m = 2 og n = 3, så m + n = 5.
- Nå har vi en to-peker. En første peker som peker på den første posisjonen på liste 1 og den andre pekeren som peker på den første posisjonen på liste 2.
4. Så vil vi sammenligne verdien av begge pekere. Pekeren med mindre verdi, kopier det elementet til liste 3 og flytt pekeren til høyre for listen med mindre verdi og den resulterende listen (dvs. liste 1 og liste 3).
5. Utfør trinn 4 igjen og igjen.
Ytterligere å krysse …
MERKNAD: Hvis en av listene (dvs. liste 1 eller liste 2) blir fullstendig krysset som i ovennevnte tilfelle, kopierer du hele innholdet i andre lister fra pekeren til resultatlisten (dvs. liste 3) som følger.
Algoritme og pseudokode
De to algoritmene som brukes i flette algoritmer er:
- MERGE (ARR, F, M, L) er en prosess som forutsetter følgende:
- ARR (F… .M) og ARR (M + 1… .L) er sorterte lister.
- Slår sammen de to sorterte dellistene til en ARR (F… .L).
- SORT (ARR (), F, L) // her F er den første og L er den siste indeksen for matrisen.
Hvis (L> 1)
- Finn midtpunktet for å dele listen i to halvdeler:
midtre M = (F + L) / 2
- Call Merge Sort for første halvår:
Ring SORT (ARR, 1, M)
- Call Merge Sort for andre omgang:
Ring SORT (ARR, M + 1, L)
- Slå sammen halvdelene sortert i trinn 2 og 3:
Ring MERGE (ARR, L, M, R)
Eksempel
La oss ta et eksempel på en gruppe ARR (10, 6, 8, 5, 7, 3, 4). Vi vil bruke Merge Algorithm for å sortere Array ved hjelp av Divide and Conquer-teknikken. Vi kan se figuren nedenfor at Array er rekursivt delt i to halvdeler til størrelsen blir 1. Når størrelsen blir 1, så kaller vi fletteprosesser og starter sammenslåingslister tilbake til den komplette listen er slått sammen.
MERKNAD: I figuren nedenfor viser tallene i rødt rekkefølgen trinnene blir behandlet for å danne den sorterte matrisen.
Programkode:
import java.util.Scanner;
public class mergeSort (
// merges two sublists of arr().
// first list is arr(l..m) // second list is arr(m+1..r) void mergeAlgo(int arr(), int l, int m, int r)
(
// find the sizes of two lists to be merged
int n1 = m - l + 1;
int n2 = r - m;
// create temp array
int L() = new int (n1);
int R() = new int (n2);
// copy data to temp arrays
for (int i=0; i L(i) = arr(l + i);
for (int j=0; j R(j) = arr(m + 1+ j);
/* merge the temp arrays */
// initial indexes of first and second list
int i = 0, j = 0;
// initial index of merged sub list
int k = l;
while (i < n1 && j < n2)
(
if (L(i) <= R(j))
(
arr(k) = L(i);
i++;
)
else
(
arr(k) = R(j);
j++;
)
k++;
)
// copy remaining elements of L() if any
while (i < n1)
(
arr(k) = L(i);
i++;
k++;
)
// copy remaining elements of R() if any
while (j < n2)
(
arr(k) = R(j);
j++;
k++;
)
)
// main function that sorts arr(l..r) using mergeAlgo()
void sort(int arr(), int l, int r)
(
if (l < r)
(
// find the middle index
int m = (l+r)/2;
// sort first and second halves
sort(arr, l, m);
sort(arr, m+1, r);
// merge the above two sorted halves
mergeAlgo(arr, l, m, r);
)
)
/* A function to print list of size n */
static void printArray(int arr())
(
int n = arr.length;
for (int i=0; i System.out.print(arr(i) + " ");
System.out.println();
)
public static void main(String args())
(
Scanner myObj = new Scanner(System.in);
System.out.println("Enter the size of list:");
int N = myObj.nextInt();
System.out.println("Enter the elements in list separated by space:");
int arr() = new int(N);
for(int i=0; i arr(i) = myObj.nextInt();
)
mergeSort mg = new mergeSort();
mg.sort(arr, 0, arr.length-1);
System.out.println("\nSorted list:");
printArray(arr);
)
)import java.util.Scanner;
public class mergeSort (
// merges two sublists of arr().
// first list is arr(l..m) // second list is arr(m+1..r) void mergeAlgo(int arr(), int l, int m, int r)
(
// find the sizes of two lists to be merged
int n1 = m - l + 1;
int n2 = r - m;
// create temp array
int L() = new int (n1);
int R() = new int (n2);
// copy data to temp arrays
for (int i=0; i L(i) = arr(l + i);
for (int j=0; j R(j) = arr(m + 1+ j);
/* merge the temp arrays */
// initial indexes of first and second list
int i = 0, j = 0;
// initial index of merged sub list
int k = l;
while (i < n1 && j < n2)
(
if (L(i) <= R(j))
(
arr(k) = L(i);
i++;
)
else
(
arr(k) = R(j);
j++;
)
k++;
)
// copy remaining elements of L() if any
while (i < n1)
(
arr(k) = L(i);
i++;
k++;
)
// copy remaining elements of R() if any
while (j < n2)
(
arr(k) = R(j);
j++;
k++;
)
)
// main function that sorts arr(l..r) using mergeAlgo()
void sort(int arr(), int l, int r)
(
if (l < r)
(
// find the middle index
int m = (l+r)/2;
// sort first and second halves
sort(arr, l, m);
sort(arr, m+1, r);
// merge the above two sorted halves
mergeAlgo(arr, l, m, r);
)
)
/* A function to print list of size n */
static void printArray(int arr())
(
int n = arr.length;
for (int i=0; i System.out.print(arr(i) + " ");
System.out.println();
)
public static void main(String args())
(
Scanner myObj = new Scanner(System.in);
System.out.println("Enter the size of list:");
int N = myObj.nextInt();
System.out.println("Enter the elements in list separated by space:");
int arr() = new int(N);
for(int i=0; i arr(i) = myObj.nextInt();
)
mergeSort mg = new mergeSort();
mg.sort(arr, 0, arr.length-1);
System.out.println("\nSorted list:");
printArray(arr);
)
)import java.util.Scanner;
public class mergeSort (
// merges two sublists of arr().
// first list is arr(l..m) // second list is arr(m+1..r) void mergeAlgo(int arr(), int l, int m, int r)
(
// find the sizes of two lists to be merged
int n1 = m - l + 1;
int n2 = r - m;
// create temp array
int L() = new int (n1);
int R() = new int (n2);
// copy data to temp arrays
for (int i=0; i L(i) = arr(l + i);
for (int j=0; j R(j) = arr(m + 1+ j);
/* merge the temp arrays */
// initial indexes of first and second list
int i = 0, j = 0;
// initial index of merged sub list
int k = l;
while (i < n1 && j < n2)
(
if (L(i) <= R(j))
(
arr(k) = L(i);
i++;
)
else
(
arr(k) = R(j);
j++;
)
k++;
)
// copy remaining elements of L() if any
while (i < n1)
(
arr(k) = L(i);
i++;
k++;
)
// copy remaining elements of R() if any
while (j < n2)
(
arr(k) = R(j);
j++;
k++;
)
)
// main function that sorts arr(l..r) using mergeAlgo()
void sort(int arr(), int l, int r)
(
if (l < r)
(
// find the middle index
int m = (l+r)/2;
// sort first and second halves
sort(arr, l, m);
sort(arr, m+1, r);
// merge the above two sorted halves
mergeAlgo(arr, l, m, r);
)
)
/* A function to print list of size n */
static void printArray(int arr())
(
int n = arr.length;
for (int i=0; i System.out.print(arr(i) + " ");
System.out.println();
)
public static void main(String args())
(
Scanner myObj = new Scanner(System.in);
System.out.println("Enter the size of list:");
int N = myObj.nextInt();
System.out.println("Enter the elements in list separated by space:");
int arr() = new int(N);
for(int i=0; i arr(i) = myObj.nextInt();
)
mergeSort mg = new mergeSort();
mg.sort(arr, 0, arr.length-1);
System.out.println("\nSorted list:");
printArray(arr);
)
)import java.util.Scanner;
public class mergeSort (
// merges two sublists of arr().
// first list is arr(l..m) // second list is arr(m+1..r) void mergeAlgo(int arr(), int l, int m, int r)
(
// find the sizes of two lists to be merged
int n1 = m - l + 1;
int n2 = r - m;
// create temp array
int L() = new int (n1);
int R() = new int (n2);
// copy data to temp arrays
for (int i=0; i L(i) = arr(l + i);
for (int j=0; j R(j) = arr(m + 1+ j);
/* merge the temp arrays */
// initial indexes of first and second list
int i = 0, j = 0;
// initial index of merged sub list
int k = l;
while (i < n1 && j < n2)
(
if (L(i) <= R(j))
(
arr(k) = L(i);
i++;
)
else
(
arr(k) = R(j);
j++;
)
k++;
)
// copy remaining elements of L() if any
while (i < n1)
(
arr(k) = L(i);
i++;
k++;
)
// copy remaining elements of R() if any
while (j < n2)
(
arr(k) = R(j);
j++;
k++;
)
)
// main function that sorts arr(l..r) using mergeAlgo()
void sort(int arr(), int l, int r)
(
if (l < r)
(
// find the middle index
int m = (l+r)/2;
// sort first and second halves
sort(arr, l, m);
sort(arr, m+1, r);
// merge the above two sorted halves
mergeAlgo(arr, l, m, r);
)
)
/* A function to print list of size n */
static void printArray(int arr())
(
int n = arr.length;
for (int i=0; i System.out.print(arr(i) + " ");
System.out.println();
)
public static void main(String args())
(
Scanner myObj = new Scanner(System.in);
System.out.println("Enter the size of list:");
int N = myObj.nextInt();
System.out.println("Enter the elements in list separated by space:");
int arr() = new int(N);
for(int i=0; i arr(i) = myObj.nextInt();
)
mergeSort mg = new mergeSort();
mg.sort(arr, 0, arr.length-1);
System.out.println("\nSorted list:");
printArray(arr);
)
)import java.util.Scanner;
public class mergeSort (
// merges two sublists of arr().
// first list is arr(l..m) // second list is arr(m+1..r) void mergeAlgo(int arr(), int l, int m, int r)
(
// find the sizes of two lists to be merged
int n1 = m - l + 1;
int n2 = r - m;
// create temp array
int L() = new int (n1);
int R() = new int (n2);
// copy data to temp arrays
for (int i=0; i L(i) = arr(l + i);
for (int j=0; j R(j) = arr(m + 1+ j);
/* merge the temp arrays */
// initial indexes of first and second list
int i = 0, j = 0;
// initial index of merged sub list
int k = l;
while (i < n1 && j < n2)
(
if (L(i) <= R(j))
(
arr(k) = L(i);
i++;
)
else
(
arr(k) = R(j);
j++;
)
k++;
)
// copy remaining elements of L() if any
while (i < n1)
(
arr(k) = L(i);
i++;
k++;
)
// copy remaining elements of R() if any
while (j < n2)
(
arr(k) = R(j);
j++;
k++;
)
)
// main function that sorts arr(l..r) using mergeAlgo()
void sort(int arr(), int l, int r)
(
if (l < r)
(
// find the middle index
int m = (l+r)/2;
// sort first and second halves
sort(arr, l, m);
sort(arr, m+1, r);
// merge the above two sorted halves
mergeAlgo(arr, l, m, r);
)
)
/* A function to print list of size n */
static void printArray(int arr())
(
int n = arr.length;
for (int i=0; i System.out.print(arr(i) + " ");
System.out.println();
)
public static void main(String args())
(
Scanner myObj = new Scanner(System.in);
System.out.println("Enter the size of list:");
int N = myObj.nextInt();
System.out.println("Enter the elements in list separated by space:");
int arr() = new int(N);
for(int i=0; i arr(i) = myObj.nextInt();
)
mergeSort mg = new mergeSort();
mg.sort(arr, 0, arr.length-1);
System.out.println("\nSorted list:");
printArray(arr);
)
)
Produksjon:
Konklusjon - Slå sammen sorteringsalgoritmer i Java
Sammenslåing av best mulig, verste og gjennomsnittlige tilfelle av tid er den samme, noe som gjør det til en mer effektiv algoritme. Det fungerer raskere enn andre sorteringsteknikker. Merge sort kan brukes på filer av alle størrelser. Den er svært parallelliserbar på grunn av bruken av skillet og erobre metoden. For å utvikle sterke grunnleggende fag innen informatikk, anbefales du å forstå forskjellige sorteringsalgoritmer grundig.
Anbefalte artikler
Dette er en guide til fletting av sorteringsalgoritmer i Java. Her diskuterer vi Implementering of Merge Sorting Algorithms in java and Algorithm & Pseudocode med eksempel. Du kan også gå gjennom andre foreslåtte artikler–
- Valg Sorter i Java
- Saksuttalelse i Java
- Få tilgang til modifikatorer i Java
- Merge Sorter i JavaScript
- Hva er saksuttalelse i JavaScript?
- Få tilgang til modifikatorer i PHP
- Rask sorteringsalgoritmer i Java
- Komplett guide til sortering i C # med eksempler
- Sorteringsfunksjon i Python med eksempler
- Topp 6 sorteringsalgoritme i JavaScript