Třídění algoritmů v Javě Různé typy třídicích algoritmů v Javě

• Úvod do třídění algoritmů v Javě

Úvod do třídění algoritmů v Javě

Třídění informací v určitém pořadí, často v rámci typu pole, je uspořádat. Můžete použít různé požadavky na sekvenci, populární jsou třídění čísel od nejmenších po největší nebo naopak, nebo lexikograficky třídící řetězce. Pokrýváme různé algoritmy, od neefektivních, ale intuitivních alternativ, až po efektivní algoritmy efektivně implementované v jazyce Java a v jiných jazycích, pokud vás zajímá, jak má třídění fungovat.

Různé třídicí algoritmy v java

Existují různé třídicí algoritmy a ne všechny jsou stejně účinné. Abychom je mohli porovnat a zjistit, které z nich mají nejlepší výkon, analyzujeme jejich časové složitosti.

1. Třídění vložení
2. Řazení bublin
3. Výběr Třídit
4. Sloučit třídění
5. Heapsort

1. Vložení řazení

Koncept zařazení třídění rozděluje rozsah na dílčí pole, která jsou tříděna a netříděna. Klasifikovaná část je na začátku trvání 1 a odpovídá první (levé straně) komponentě v poli. Během každé iterace procházíme maticí a rozšiřujeme klasifikovanou část pole o jednu komponentu. Když se rozbalíme, umístíme čerstvý prvek do tříděného dílčího pole. Děláme to tak, že přesuneme všechny prvky doprava, dokud nezjistíme, že nemusíme měnit první komponentu. Když je tučná část seřazena ve vzestupném pořadí, například v následujícím poli, nastane:

1. 3 5 7 8 4 2 1 9 6: Zvažte 4 a vložte je to, co potřebujeme. Přesouváme se od 8> 4
2. 2. 3 5 7 x 8 2 1 9 6
3. 3 5 x 7 8 2 1 9 6
4. 3 x 5 7 8 2 1 9 6
5. 3 4 5 7 8 2 1 9 6

Kód:

public class InsertionSortEx (
public static void insertionSort(int() arr) (
for (int x = 1; x < arr.length; x++) (
int current = arr(x);
int y = x - 1;
while(y >= 0 && current < arr(y)) (
arr(y+1) = arr(y);
y--;
)
arr(y+1) = current;
)
)
public static void main(String a())(
int() arr1 = (3, 5, 7, 8, 4, 2, 1, 9, 6);
System.out.println("Before Sorting");
for(int x:arr1)(
System.out.print(x+" ");
)
System.out.println();
insertionSort(arr1);//sorting array using insertion sort
System.out.println("After Insertion Sorting");
for(int x:arr1)(
System.out.print(x+" ");
)
)
)

Výstup:

Podle této metody jedna součást rozšířila tříděnou součást, nyní máme pět namísto čtyř prvků. Každá iterace to provede a celé pole bude seřazeno podle konce.

Poznámka: Je to proto, že musíme převádět celý utajovaný seznam jeden po druhém v každé iteraci, což je O (n). U každé komponenty v každé tabulce to musíme udělat, což znamená, že je O (n 2) ohraničeno.2.

2. Řazení bublin

Pokud bublina není v požadovaném pořadí, funguje výměnou sousedních komponent. Toto se opakuje, dokud nejsou všechny komponenty v pořádku od začátku pole. Víme, že pokud se nám podaří provést celou iteraci bez swapů, všechny položky ve srovnání s jejich sousedními prvky byly v žádoucím pořadí a rozšířením celé pole. Důvodem pro algoritmus řazení bublin je to, že čísla jako „vzhůru“ do „země“. Pokud po určité částce znovu projdete instancí (4 je dobrá instance), všimnete si, že číslo pomalu se pohybuje doprava.

Kroky k třídění bublin jsou následující:

1. 4 2 1 5 3: Zde nejsou ^první dvě čísla ve správném pořadí, proto musíme obě čísla třídit.
2. 2 4 1 5 3: Poté další pár čísel také není ve správném pořadí. Takže třídění probíhá znovu.
3. 2 1 4 5 3: Tito dva jsou ve správném pořadí, 4 <5, není tedy nutné je vyměňovat.
4. 2 1 4 5 3 : Znovu musíme vyměnit za řádné pořadí.
5. 2 1 4 3 5: Zde je výsledné pole po jedné iteraci.
6. Tento proces musíme opakovat, dokud nebudou čísla v pořádku.

Kód:

public class BubbleSortExample (
public static void bubbleSort(int() arr) (
int n = arr.length;
int tmp = 0;
for(int x=0; x < n; x++)(
for(int y=1; y < (nx); y++)(
if(arr(y-1) > arr(y))(
//swap elements
tmp = arr(y-1);
arr(y-1) = arr(y);
arr(y) = tmp;
)
)
)
)
public static void main(String() args) (
int arr() =(4, 2, 1, 5, 3);
System.out.println("Array Before Bubble Sort");
for(int x=0; x < arr.length; x++)(
System.out.print(arr(x) + " ");
)
System.out.println();
bubbleSort(arr);
System.out.println("Array After Bubble Sort");
for(int x=0; x < arr.length; x++)(
System.out.print(arr(x) + " ");
)
)
)

Výstup:

Poznámka: Mohlo by to skončit v nekonečné smyčce, kdybych použil (i)> = a (i + 1), protože toto spojení by stále bylo platné s ekvivalentními komponenty, a tak je vždy zaměňujte z jednoho prvku na druhý.

3. Výběr řazení

Výběr třídění rozdělí pole do pole klasifikací, které nejsou tříděny. Tentokrát je však třídění třídicího pole vytvořeno vložením na konec tříděného pole minimálním prvkem netříděného dílčího pole zaměněním:

1. 3 5 1 2 4
2. 1 5 3 2 4
3. 1 2 3 5 4
4. 1 2 3 5 4
5. 1 2 3 4 5
6. 1 2 3 4 5

Kód:

public class SelectionSortEx (
public static void selectionSort(int() arr)(
for (int x = 0; x < arr.length - 1; x++)
(
int indx = x;
for (int y = x + 1; y < arr.length; y++)(
if (arr(y) < arr(indx))(
indx = y;
)
)
int smallNumber = arr(indx);
arr(indx) = arr(x);
arr(x) = smallNumber;
)
)
public static void main(String a())(
int() arr1 = (3, 5, 1, 2, 4);
System.out.println("Before Sorting");
for(int x:arr1)(
System.out.print(x+" ");
)
System.out.println();
selectionSort(arr1);
System.out.println("After Selection Sorting");
for(int x:arr1)(
System.out.print(x+" ");
)
)
)

Výstup:

Poznámka: Minimální velikost je O (n) pro velikost pole, protože musí být zkontrolovány všechny komponenty. Pro každý prvek pole musíme najít minimum a omezit celý proces O (n 2).

4. Sloučit řazení

Sloučit třídění využívá rekurzi k vyřešení problému metody rozdělení a dobytí efektivněji než dříve popsané algoritmy.

Tento strom ukazuje, jak fungují rekurzivní hovory. Pole označená šipkou dolů jsou pole, pro něž voláme funkci, zatímco pojistky se šipkami nahoru pojistíme. Poté sledujte šipku k okraji stromu a poté se vraťte a sloučte. Máme řadu 3 5 3 1, takže jsme ji rozdělili na 3 5 4 a 2 1. Rozdělili jsme je na jejich části, abychom je mohli třídit. Když se dostaneme ke dnu, začneme je fúzovat a třídit.

Kód:

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
public class MergeSort (
static void merge(int() array, int lowval, int midval, int highval)(
int x, y, k;
int() c= new int(highval-lowval+1);
k = 0;
x=lowval;
y=midval+1;
while(x<=midval && y<=highval)(
if(array(x)<=array(y))(
c(k++) = array(x++);
)
else(
c(k++) = array(y++);
)
)
while(x<=midval)(
c(k++) = array(x++);
)
while(y<=highval)(
c(k++) = array(y++);
)
k=0;
for(x = lowval; x<=highval; x++)(
array(x) = c(k++);
)
)
static void mergeSort(int() array, int lowval, int highval)(
if(highval-lowval+1>1)(
int midval = (lowval+highval)/2;
mergeSort(array, lowval, midval);
mergeSort(array, midval+1, highval);
merge(array, lowval, midval, highval);
)
)
public static void main(String() args) (
BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
int size;
System.out.println("Enter the array");
try (
size = Integer.parseInt(r.readLine());
) catch (Exception e) (
System.out.println("Please Enter valid Input");
return;
)
int() array = new int(size);
System.out.println("Enter array elements");
int x;
for (x = 0; x < array.length; x++) (
try (
array(x) = Integer.parseInt(r.readLine());
) catch (Exception e) (
System.out.println("An error Occurred");
)
)
System.out.println("After Sorting");
System.out.println(Arrays.toString(array));
mergeSort(array, 0, array.length-1);
System.out.println("Before Merge Sorting");
System.out.println(Arrays.toString(array));
)
)

V tomto programu jsme požádali uživatele o zadání vstupu. Výstup bude seřazen podle vstupu uživatele.

Výstup:

5. Hromadné třídění

Nejprve musíte znát rámec, na kterém Heapsort pracuje - halda, abyste pochopili, proč funguje. Budeme hovořit konkrétně o binární haldy, ale můžete ji také zobecnit na jiné konstrukce haldy. Hromada je strom, který splňuje vlastnost haldy, konkrétně že všechny její děti mají vztahy s každým uzlem. Halda musí být také téměř hotová. Téměř kompletní binární d-hloubka má podstrom d-1, se stejným kořenem, a každý uzel má plný, levý podstrom, s levým klesáním.

Jinými slovy, při pohybu dolů stromem získáte nižší a nižší číslo (min-haldy) nebo větší a větší (max-haldy). Zde je instanci s maximálním počtem haldy:

1. 6 1 8 3 5 2 4 : Zde jsou obě čísla dětí menší než rodiče, takže nemusíme nic měnit.
2. 6 1 8 3 5 2 4: Zde, 5> 1, musíme je vyměnit. Potřebujeme healifikovat po dobu 5.
3. 6 5 8 3 1 2 4: Obě čísla dětí jsou menší, všechno zůstává stejné.
4. 6 5 8 3 1 2 4: Zde, 8> 6, měli bychom je proto vyměnit.
5. 8 5 6 3 1 2 4: Po této iteraci získáme tento výsledek.

Po opakování tohoto procesu znovu získáme následující výsledky:

• 8 5 6 3 1 2 4

1. 4 5 6 3 1 2 8 : Výměna
2. 6 5 4 3 1 2 8 : Heapify
3. 2 5 4 3 1 6 8 : Výměna
4. 5 2 4 2 1 6 8 : Heapify
5. 1 2 4 2 5 6 8 : Výměna

Kód:

public class HeapSort
(
public void sort(int arr())
(
int n = arr.length;
for (int x = n / 2 - 1; x >= 0; x--)
heapify(arr, n, x);
for (int x=n-1; x>=0; x--)
int tmp = arr(0);
arr(0) = arr(x);
arr(x) = tmp;
heapify(arr, x, 0);
)
)
void heapify(int arr(), int n, int x)
(
int largest = x;
int L = 2*x + 1;
int r = 2*x + 2;
if (L arr(largest))
largest = L;
if (r arr(largest))
largest = r;
if (largest != x)
(
int swap = arr(x);
arr(x) = arr(largest);
arr(largest) = swap;
heapify(arr, n, largest);
)
)
static void printArray(int arr())
(
int n = arr.length;
for (int x=0; x System.out.print(arr(x)+" ");
System.out.println();
)
public static void main(String args())
(
int arr() = (6, 1, 8, 3, 5, 2, 4);
int n = arr.length;
System.out.println("Before Sorting:");
printArray(arr);
HeapSort ob = new HeapSort();
ob.sort(arr);
System.out.println("After Heap Sorting:");
printArray(arr);
)
) public class HeapSort
(
public void sort(int arr())
(
int n = arr.length;
for (int x = n / 2 - 1; x >= 0; x--)
heapify(arr, n, x);
for (int x=n-1; x>=0; x--)
int tmp = arr(0);
arr(0) = arr(x);
arr(x) = tmp;
heapify(arr, x, 0);
)
)
void heapify(int arr(), int n, int x)
(
int largest = x;
int L = 2*x + 1;
int r = 2*x + 2;
if (L arr(largest))
largest = L;
if (r arr(largest))
largest = r;
if (largest != x)
(
int swap = arr(x);
arr(x) = arr(largest);
arr(largest) = swap;
heapify(arr, n, largest);
)
)
static void printArray(int arr())
(
int n = arr.length;
for (int x=0; x System.out.print(arr(x)+" ");
System.out.println();
)
public static void main(String args())
(
int arr() = (6, 1, 8, 3, 5, 2, 4);
int n = arr.length;
System.out.println("Before Sorting:");
printArray(arr);
HeapSort ob = new HeapSort();
ob.sort(arr);
System.out.println("After Heap Sorting:");
printArray(arr);
)
)

Výstup:

Můžete jej zobrazit od bodu k úrovni grafu, zleva doprava. Zde jsme dosáhli toho, že když máme v poli kth komponentu, pozice jejích dětí je 2 \ * k + 1 a 2 \ * k + 2 (za předpokladu, že indexování začíná na 0). To můžete sledovat vy. Pozice rodiče je vždy (k-1) / 2 pro komponentu kth. Můžete snadno „maximalizovat hromadu“ libovolného rozsahu, protože to víte. Zkontrolujte, zda je jedno z jeho dětí nižší než u každé součásti. Pokud ano, spárujte jednoho z rodičů a opakujte tento krok rekurzivně s rodičem.

Poznámka: Protože iterace smyček napříč celým polem vytváří heapSort) (samozřejmě O (N), vytvořilo by to celkovou složitost Heapsort O (nlog n). Heapsort má typ na místě, což znamená, že vyžaduje O ( 1) více místa než Sloučit třídění, ale má některé nevýhody, jako jsou tvrdé paralely.

Závěr - Třídění algoritmů v Javě

Třídění je velmi rozšířený postup s datovými sadami, ať už pro další analýzu, zrychlení vyhledávání pomocí efektivnějších algoritmů založených na tříděných informacích, filtrování informací atd. Třídění je podporováno několika jazyky a rozhraní často zakrývají to, co programátor dělá.

Doporučené články

Toto je průvodce tříděním algoritmů v Javě. Zde diskutujeme různé typy třídění v Javě spolu s jejich algoritmy. Můžete si také prohlédnout naše další doporučené články -

1. Sloučit třídění algoritmů v Javě
2. JComboBox v Javě
3. StringBuffer v Javě
4. JTextField v Javě
5. Haldy Seřadit v Pythonu
6. Algoritmy rychlého třídění v Javě
7. Kompletní průvodce tříděním v C # s příklady
8. Třídění algoritmů v JavaScriptu
9. Průvodce příklady C ++ algoritmů
10. Kompletní průvodce třídícími algoritmy v Pythonu