Introduktion til flette sorteringsalgoritmer i Java
Flettsorteringsalgoritmer er meget vigtige inden for datalogi. Outputet fra sorteringen er at arrangere elementerne i en liste i en bestemt rækkefølge (enten stigende eller faldende). Flettesortering er en af de mest effektive sorteringsalgoritmer, der er tilgængelige, da den er baseret på begrebet kløft og erobringer. Som navnet antyder, skal du først opdele det større problem i små problemer end løse de mindre problemer for at løse det større problem. I denne artikel vil vi diskutere flette sorteringsalgoritmer i Java. Konceptuelt er Merge sort en kombination af to grundlæggende algoritmer kaldet MERGE og MERGE_SORT, der fungerer som følger:
- Opdel den usorterede liste i n antal undelister med enkeltelementer (n er det samlede antal elementer i den usorterede liste).
- Bland gentagne gange sublister til sorterede sublister, indtil der kun er en sorteret liste.
Implementering af flettsorteringsalgoritmer i Java
MERGE-algoritmen er proceduren for at kombinere to sorterede lister til en sorteret liste.
Eksempel: Antag, at der er to lister, dvs. liste 1 (6, 3) og liste 2 (3, 1, 9).
1. Sorter først begge lister.
Liste 1
Liste 2
Nu vil vi anvende en fusioneringsteknik på den.
- Derefter vil vi oprette en ny liste over størrelse m + n, hvor m er antallet af elementer i liste 1 og n er antallet af elementer i liste 2.
Liste 3
I vores tilfælde er m = 2 og n = 3, så m + n = 5.
- Nu har vi en to-pointer. En første markør, der peger på den første position på liste 1 og den anden pointer, der peger på den første position på liste 2.
4. Så sammenligner vi værdien af begge pegere. Markøren med mindre værdi, kopier dette element til liste 3 og flyt markøren til højre for listen med mindre værdi og den resulterende liste (dvs. liste 1 og liste 3).
5. Udfør på samme måde trin 4 igen og igen.
Yderligere krydsning… ..
BEMÆRK: Hvis en af listerne (dvs. liste 1 eller liste 2) bliver gennemgået fuldt ud som i ovenstående tilfælde, skal du kopiere hele indholdet af andre lister fra markøren til resultatlisten (dvs. liste 3) som følger.
Algoritme og pseudokode
De to algoritmer, der bruges i fletningsalgoritme, er:
- MERGE (ARR, F, M, L) er en proces, der antager følgende:
- ARR (F… .M) og ARR (M + 1… .L) er sorterede lister.
- Fusionerer de to sorterede underlister til en ARR (F… .L).
- SORT (ARR (), F, L) // her F er den første og L er den sidste indeks i matrixen.
Hvis (L> 1)
- Find det midterste punkt for at opdele listen i to halvdele:
midterste M = (F + L) / 2
- Call Merge Sort for den første halvdel:
Ring SORT (ARR, 1, M)
- Call Merge Sort for anden halvdel:
Ring SORT (ARR, M + 1, L)
- Flet halvdelene sorteret i trin 2 og 3:
Ring til MERGE (ARR, L, M, R)
Eksempel
Lad os tage et eksempel på en matrix ARR (10, 6, 8, 5, 7, 3, 4). Vi vil bruge fletningsalgoritmen til at sortere matrixen ved hjælp af dens skille- og erobringsteknik. Vi kan se nedenstående figur, at Array er rekursivt opdelt i to halvdele, indtil størrelsen bliver 1. Når størrelsen bliver 1, kalder vi fletningsprocesser og begynder at flette lister tilbage, indtil den komplette liste er slået sammen.
BEMÆRK: I nedenstående figur viser numrene i rødt den rækkefølge, i hvilken trinnene behandles til dannelse af den sorterede matrix.
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);
)
)
Produktion:
Konklusion - Flet sorteringsalgoritmer i Java
Flet sortering af bedste, værste og gennemsnitlige tilfælde er de samme, hvilket gør det til en mere effektiv algoritme. Det fungerer hurtigere end andre sorteringsteknikker. Flettsortering kan anvendes på filer af enhver størrelse. Det er meget paralleliserbart på grund af brugen af divide-and-conquer-metoden. For at udvikle stærke grundlæggende inden for datalogi rådes du til grundigt at forstå forskellige sorteringsalgoritmer.
Anbefalede artikler
Dette er en guide til fletning af sorteringsalgoritmer i Java. Her diskuterer vi Implementering af flettsorteringsalgoritmer i java og algoritme & pseudokode med eksempel. Du kan også gennemgå vores andre foreslåede artikler–
- Valgssortering i Java
- Sagerklæring i Java
- Få adgang til modifikatorer i Java
- Flet Sortér i JavaScript
- Hvad er sagopgørelse i JavaScript?
- Få adgang til modifikatorer i PHP
- Hurtig sorteringsalgoritmer i Java
- Komplet guide til sortering i C # med eksempler
- Sorteringsfunktion i Python med eksempler
- Top 6 sorteringsalgoritme i JavaScript