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

Podobně jako většina ostatních programovacích jazyků, můžete narazit na scénáře, ve kterých musíte třídit některá čísla v JavaScriptu do vzestupného nebo sestupného pořadí. Abychom to dokázali, můžeme použít mnoho algoritmů, jako je třídění bublin, třídění výběru, sloučení třídění, Quicksort atd. Tyto algoritmy se liší nejen tím, jak fungují, ale také každý má své odlišné požadavky z hlediska paměti a času, hlouběji si prohlédněte některé důležité algoritmy třídění a podívejte se, jak je můžete použít ve svém kódu JavaScript.

Top 6 třídících algoritmů v JavaScriptu

Zde jsou některé algoritmy třídění v javascriptu vysvětlené níže s příklady:

1. Algoritmus řazení bublin

Považován za jeden z nejčastějších nástrojů tohoto obchodu, Bubble sort funguje tak, že vytvoří smyčku, která porovnává každou položku v poli s jinou položkou. Pokud je porovnávaná položka menší než ta, která je po ruce, zaměníme jejich místa. To pokračuje, dokud nemáme průchod, kde žádná položka v poli není větší než položka, která je vedle ní.

Řazení bublin má O (n 2 ) časovou složitost a O (n) prostorovou složitost.

Kód:

function swap(arr, firstIndex, secondIndex)(
var temp = arr(firstIndex);
arr(firstIndex) = arr(secondIndex);
arr(secondIndex) = temp;
)
function bubbleSortAlgo(arraaytest)(
var len = arraaytest.length,
i, j, stop;
for (i=0; i < len; i++)(
for (j=0, stop=len-i; j < stop; j++)(
if (arraaytest(j) > arraaytest(j+1))(
swap(arraaytest, j, j+1);
)
)
)return arraaytest;
)
console.log(bubbleSortAlgo((3, 6, 2, 5, -75, 4, 1)));

Výstup:

2. Výběr Algoritmus řazení

Nyní, když jsme skončili s diskusí o algoritmu třídění bublin, pojďme se podívat stejně jako populární algoritmus pro třídění zvaný Výběr třídění.

Na rozdíl od Bubble Sort se zaměřujeme na nalezení nejmenší hodnoty v poli, aby se třídění provedlo. Zde je podrobný přehled toho, jak funguje výběrové řazení:

  • První položku v poli považujeme za nejmenší.
  • Porovnáme tuto položku s další položkou v poli.
  • Pokud je další položka menší než ta, která je po ruce, nastavíme další položku jako novou nejmenší hodnotu.
  • Tyto kroky opakujeme, dokud nedosáhneme konce pole.
  • Když najdeme hodnotu v poli, která je menší než ta, kterou jsme začali, zaměníme jejich pozice.
  • Stále děláme srovnání a přejdeme k další položce. Dokud nebude celé pole seřazeno.

Stejně jako algoritmus třídění bublin, má výběrové řazení O (n 2 ) časovou složitost a O (n) prostorovou složitost.

Kód:

function SelectionSortAlgo(array, compare_Function) (
function comp(a, b) (
return a - b;
)
var min = 0;
var index = 0;
var temp = 0;
compare_Function = compare_Function || compare;
for (var i = 0; i < array.length; i += 1) (
index = i;
min = array(i);
for (var j = i + 1; j < array.length; j += 1) (
if (compare_Function(min, array(j)) > 0) (
min = array(j);
index = j;
)
)
temp = array(i);
array(i) = min;
array(index) = temp;
)
return array;
)
console.log(SelectionSortAlgo((9, 15, 2, 44, -1, 36, 1), function(a, b) ( return a - b; )));

Výstup:

3. Sloučení algoritmu třídění

Podobně jako Bubble Sort and Selection Sort, Merge sort je jedním z populárních třídicích algoritmů v informatice, můžete jej implementovat do většiny programovacích jazyků a má dobrý výkon, aniž by to bylo příliš potřebné na zdroje.

Sloučit řazení používá k rozdělení pole nebo seznamu prvků metodu Rozdělit a dobýt. Termín rozděluje a dobývá znamená, že jeden velký problém rozdělíme na několik menších problémů a potom tyto malé problémy vyřešíme. Jakmile jsou menší problémy vyřešeny, kombinujeme výsledky, které vedou k řešení velkého problému.

Pochopení algoritmu je ve skutečnosti jednoduché:

  • Dané pole rozdělíme do n polí, z nichž každá obsahuje pouze 1 prvek.
  • Sloučením polí vytvořte nové pole.
  • Opakujte krok 2, dokud nezůstane pouze 1 pole, což bude seřazené pole.

Kód:

function merge_sort_algo(left, right)
(
var i = 0;
var j = 0;
var result = ();
while (i < left.length || j < right.length) (
if (i === left.length) (
// j is the only index left_part
result.push(right(j));
j++;
)
else if (j === right.length || left(i) <= right(j)) (
result.push(left(i));
i++;
) else (
result.push(right(j));
j++;
)
)
return result;
)
console.log(merge_sort_algo((1, 44, 6), (84, 7, 5)));

Výstup:

4. Algoritmus rychlého třídění

Quicksort je jedním z nejúčinnějších způsobů třídění prvků v počítačových systémech. Program Quicksort, který umožňuje sloučit řazení, pracuje na algoritmu rozdělení a dobytí. V tomto najdeme v poli pivotní položku, abychom mohli porovnat všechna pole ostatních prvků proti, a potom přesuneme položky tak, aby všechny položky před našimi vybranými pivotními položkami byly menší a všechny položky za pivotní položkou byly větší. Jakmile to uděláme, klíčem je, abychom to dělali opakovaně, a my budeme mít své tříděné pole.

Následují kroky, které lze použít při implementaci algoritmu quicksort:

  • Vybereme prvek pole a nazveme jej „Pivot Point“
  • Začneme ukazatel nazvaný levý ukazatel, od kterého je na prvním prvku v poli.
  • Podobně začneme ukazatel nazvaný správný ukazatel na poslední položce v poli.
  • Pokud je hodnota prvku na levém ukazateli ve srovnání s vybraným bodem otáčení menší, přesuneme levý ukazatel doleva (přidáme do něj +1) a opakujeme jej, dokud nebude hodnota levého ukazatele větší než hodnota hodnota otočného bodu nebo rovna.
  • Pokud je hodnota prvku na pravém ukazateli v seznamu vyšší než hodnota otočného prvku, přepneme pravý ukazatel doleva. Tento postup opakujte, dokud není hodnota na pravém postranním ukazateli nižší než (nebo rovná) hodnotě pivotu.
  • Pokud je hodnota levého ukazatele menší nebo stejná jako hodnota pravého ukazatele, vyměňte je.
  • Přesuňte pravý ukazatel doleva po jednom, levý ukazatel doprava po jednom.
  • Opakujte, dokud se nesetkají levé a pravé ukazatele.

Kód:

function quickSortAlgo(origArray) (
if (origArray.length <= 1) (
return origArray;
) else (
var left = ();
var right = ();
var newArray = ();
var pivot = origArray.pop();
var length = origArray.length;
for (var i = 0; i < length; i++) (
if (origArray(i) <= pivot) (
left.push(origArray(i));
) else (
right.push(origArray(i));
)
)
return newArray.concat(quickSortAlgo(left), pivot, quickSortAlgo(right));
)
)
var myArray = (13, 50, 2, 45, -1, 74, 11 );
var arreySorted = quickSortAlgo(myArray);
console.log(arreySorted);

Výstup:

5. Algoritmus řazení vložení

Pokud jde o snadnou implementaci, druh vložení je obecně znám jako jeden z jednodušších algoritmů. Při třídění vložení jsou prvky pole porovnány navzájem a poté uspořádány v určitém pořadí. To je velmi podobné uspořádání karet v balíčku. Druh vložení názvu pochází z procesu výběru prvku a jeho vložení na správné místo a jeho opakování pro všechny prvky.

Algoritmus funguje takto:

  • První prvek pole je považován za již seřazený.
  • Vyberte další prvek pole.
  • Porovnejte vybraný prvek se všemi prvky v poli.
  • Posuňte každý prvek v poli, který je větší než hodnota vybraného prvku.
  • Vložte prvek
  • Opakujte kroky 2 až 5, dokud nebude pole seřazeno.

Kód:

function insertion_Sort_algo(arr)
(
for (var i = 1; i < arr.length; i++)
(
if (arr(i) < arr(0))
(
arr.unshift(arr.splice(i, 1)(0));
)
else if (arr(i) > arr(i-1))
(
continue;
)
else (
for (var j = 1; j < i; j++) (
if (arr(i) > arr(j-1) && arr(i) < arr(j))
(
arr.splice(j, 0, arr.splice(i, 1)(0));
)
)
)
)
return arr;
)
console.log(insertion_Sort_algo((44, 20, 26, 54, -9, 41, 16)));

Výstup:

6. Algoritmus řazení haldy

Třídění haldy je způsob třídění prvků pomocí datové struktury „Haldy“. Metoda je velmi podobná metodě výběru, kterou jsme diskutovali dříve. Nyní se možná ptáte na Heaps a jak jsou definovány, než se dostaneme k algoritmu, nejprve si vysvětlíme haldy.

Stručně řečeno, halda je binární strom s některými přidanými pravidly. Jedno pravidlo uvádí, že v haldy musí být strom úplným binárním stromem, což jednoduše znamená, že před přidáním dalšího je nutné vyplnit všechny uzly na aktuální úrovni. Další pravidlo pro haldu je, že musí existovat definovaný podřízený a nadřazený vztah s hodnotami prvků haldy.

V mincovně musí být hodnota rodiče menší než její děti. Jak můžete hádat, v maximální haldě musí být hodnota rodiče větší než její podřízená.

Nyní, když definice nejsou v pořádku, pojďme se podívat, jak heapsort funguje:

  • Nejprve vytvoříme maximální haldu, která zajistí, že prvek nejvyšší hodnoty je nahoře.
  • Přepneme horní prvek s posledním prvkem haldy, odebereme horní prvek z haldy a uložíme jej do seřazeného pole.
  • Opakujeme krok jeden a dva, dokud v haldě nezůstane pouze jeden prvek.

Jedna věc, kterou je třeba mít na paměti, je, že Heapy nejsou v JavaScriptu nativně podporovány, proto se musíme uchýlit k implementaci Heapů pomocí polí. Vesmírná složitost haldy je O (1), která je vynikající a přestože je o něco složitější ve srovnání s sloučením nebo vložením, pokud jde o porozumění a implementaci, myslím, že pro výhody z hlediska výkonu je v konečném důsledku lepší použít velké projekty.

Kód:

var arrLength;
function heapRoot(input, i) (
var left = 2 * i + 1;
var right = 2 * i + 2;
var max = i;
if (left input(max)) (
max = left;
)
if (right input(max)) (
max = right;
)
if (max != i) (
swap(input, i, max);
heapRoot(input, max);
)
)
function swap(input, index_A, index_B) (
var temp = input(index_A);
input(index_A) = input(index_B);
input(index_B) = temp;
)
function heapSortAlgo(input) (
arrLength = input.length;
for (var i = Math.floor(arrLength / 2); i >= 0; i -= 1) (
heapRoot(input, i);
)
for (i = input.length - 1; i > 0; i--) (
swap(input, 0, i);
arrLength--;
heapRoot(input, 0);
)
)
var arr = (12, 10, 22, 55, -8, 64, 14);
heapSortAlgo(arr);
console.log(arr);

Výstup:

Závěr

Třídění je důležitou součástí vytváření aplikací a webů pomocí JavaScriptu. Nyní, když jste obeznámeni s některými nejdůležitějšími algoritmy, které vám pomohou dokončit práci, byste se měli v JS Development cítit jistější.

Jedním důležitým faktem, který je třeba mít na paměti při různých třídicích postupech, je, že se nemusíte příliš zdůrazňovat, jaký algoritmus použít ve většině případů. Nyní, když je počítačový hardware tak silný, moderní procesory telefonů a stolních počítačů neztratí žádný pot při třídění ani stovek prvků za několik milisekund. Pouze v případech, kdy jste zaseknutí pomalým hardwarem nebo v situacích, kdy optimalizujete každou jednotlivou část kódu, může být užitečné změnit algoritmy řazení.

Doporučené články

Toto je průvodce tříděním algoritmů v JavaScriptu. Zde diskutujeme prvních 6 třídicích algoritmů v javascriptu spolu s příklady a implementací kódu. Další informace naleznete také v následujících článcích -

  1. Kompilátory JavaScriptu
  2. Reverzní JavaScript
  3. Úvod do JavaScriptu
  4. Čtverce v Javě
  5. Algoritmy rychlého třídění v Javě
  6. Pole ve struktuře dat
  7. Algoritmus C ++ | Příklady algoritmu C ++

Kategorie:

Vývoj softwaru