✅ Eenvoudige JavaScript-sorteeralgoritmen

Inhoudsopgave

Een algoritme is per definitie een geordende verzameling (Dit is erg belangrijk) van systematische bewerkingen waarmee we een berekening kunnen maken om de oplossing van alle problemen van hetzelfde type te vinden. Met andere woorden, het is een reeks instructies die altijd het volgende patroon volgt:

Precisie: Je moet elke stap of instructie uniek en ondubbelzinnig uitleggen.
eindig: Het aantal uit te voeren instructies moet worden beperkt.
Definitie: Dezelfde invoergegevens moeten altijd dezelfde uitvoerinformatie opleveren.
Ingang: Het aantal invoerelementen kan nul of meer zijn.
Oplossing: Het moet altijd een resultaat opleveren, wat de uitvoergegevens (en) zullen zijn.

Wanneer een algoritme in een bepaalde programmeertaal wordt geïmplementeerd, wordt het een programma dat op een computer kan worden uitgevoerd, daarom kunnen we zeggen dat een programma een algoritme of een reeks algoritmen is die in een specifieke taal zijn geschreven die de computer kan gebruiken. In dit geval wordt dit programma een rekenalgoritme genoemd. Aan de andere kant, als het geen computer nodig heeft om te draaien, hebben we het over niet-computationele algoritmen.

In ons geval gaan we het hebben over computationele algoritmen.

Wetende wat een algoritme is, gaan we ons concentreren op de sorteeralgoritmen, of wat hetzelfde is, het algoritme dat dient om een lijst te sorteren en terug te sturen die aanvankelijk is voorzien van willekeurig geplaatste elementen die al zijn geordend.
De 3 sorteeralgoritmen bekendste zijn Bellen sorteren of sorteren op bol, Selectie sorteren of sorteren op selectie en Invoegen sorteren of sorteren op invoeging. Ze worden allemaal beschouwd als eenvoudige algoritmen of methoden, omdat ze worden opgelost door iteratie of herhaling tot een aantal n keer.

1. Bellen sorteren of sorteren op bubbelAls we als voorbeeld een array met vier waarden nemen, in dit geval voor de eenvoud vier getallen, zullen we zien hoe het algoritme werkt.

Matrix = (4, 7, 8, 5, 9);

We willen dat je het bijvoorbeeld terugstuurt van hoog naar laag, dat wil zeggen (9, 8, 7, 5, 4).

Om dit te doen, moeten we eerst de eerste twee waarden vragen die de grootste is. In het geval dat de tweede waarde groter is dan de eerste, zoals het geval is, moeten ze worden geruild, aan de andere kant, als ze al zijn besteld, laten we ze zoals ze zijn.
Dan zou hetzelfde proces herhaald moeten worden met de tweede en derde waarde. In dit geval is de derde waarde groter, dus we zouden deze verwisselen, waarbij onze array = (7, 8, 4, 5, 9) blijft.
Daarna herhalen we de vorige stap met de derde en vierde waarden en wisselen we ze opnieuw uit. (7, 8, 5, 4, 9).
En uiteindelijk zou het na de eerste iteratie zijn: (7, 8, 5, 9, 4).
Het is nog steeds niet geordend, maar het is bereikt dat het laatste element, dat aan de rechterkant van het geheel, de 4, als het kleinste aantal van allemaal is geordend.
In de volgende ronde om onze array te bestellen, is het niet langer nodig om rekening te houden met de laatste omdat we al weten dat deze is geordend, dus we zouden het eerste en tweede element vergelijken, dan het tweede en derde element en tenslotte het derde en vierde element en de array zou blijven: (8, 7, 9, 5, 4).
Nu zijn het laatste en voorlaatste element gesorteerd.
We doen nog een ronde en vergelijken de eerste en tweede waarden en dan de tweede en derde en de array ziet er als volgt uit: (8, 9, 7, 5, 4).
De laatste drie elementen zijn al geordend, dus het duurt nog maar één beurt om de array volledig geordend te verlaten: (9, 8, 7, 5, 4).

Dit is hoe de burburja algoritme, die zo wordt genoemd omdat in elke beurt het laatste element als een bel omhoog komt en geordend is.

Nu geïmplementeerd om JavaScript Het is erg makkelijk:

functiebel (myArray) {var tam = myArray.length; for (var temp = 1; temp <size; temp ++) {for (var left = 0; left <(size - temp); left ++) {var right = left + 1; if (myArray [links] <myArray [rechts] {sorteer (myArray, links, rechts);}}} geef myArray terug;}

We geven een array door aan onze functie en daarin is het eerste wat we doen de grootte berekenen, het aantal elementen in de array berekenen.
Vervolgens maken we een buitenste lus die net zo vaak door onze array gaat als elementen min één hebben (aangezien dit de tijden zijn die nodig zijn om het volledig te bestellen).
Intern creëren we nog een lus die door de waarden gaat en elke met de volgende vergelijkt en als die aan de linkerkant kleiner is dan die aan de rechterkant, worden ze uitgewisseld met de sorteerfunctie die we hierna zullen zien.
Ten slotte retourneert het de geordende array.

functie sorteren (myArray, value1, value2) {var temp = myArray [waarde1]; myArray [waarde1] = myArray [waarde2]; myArray [waarde2] = temp; retourneer mijnArray;}

waarbij value1 de index is van het eerste item dat wordt geruild en value2 de index is van het tweede item dat wordt geruild.

2. Selectie sorterenHet algoritme dat we hieronder zullen zien, verplaatst de elementen niet één voor één zoals in de bel één, maar doorloopt eerst de volledige array en selecteert vervolgens het juiste element voor plaatsing volgens de criteria die we volgen (bijvoorbeeld van hoogste naar de laagste) en het plaatst het direct in zijn positie, en zo krijgt het algoritme zijn naam, selecteert, neemt een element en verplaatst het met een enkele beweging naar de juiste positie.

In hetzelfde voorbeeld als eerder Array = (4, 7, 8, 5, 9) als we het bijvoorbeeld van hoog naar laag willen ordenen, zouden we eerst 9 selecteren en deze op de eerste plaats plaatsen en 4 zou de laatste innemen positie (9, 7, 8, 5, 4). In de tweede ronde zou hij de 8 selecteren en deze verwisselen met de 7 om in de juiste positie te blijven. In de volgende rondes zou ik niets wijzigen aangezien het al besteld is.

De code van dit algoritme zou als volgt zijn:

functieselectie (myArray) {var tam = myArray.length; for (var temp = 0; temp <grootte -1; temp ++) {groot = temp; for (var check = temp + 1; check <size; check ++) {if (myArray [check] <myArray [major] {major = check;}} sort (myArray, major, check);} return myArray;}

De code werkt vergelijkbaar met die van de bubbel maar de buitenste for-lus gaat door de waarden van 0 tot N-2 (het zijn hetzelfde aantal stappen als tussen 1 en N-1 als in de bubbel maar de werking is anders ) direct op de elementen werken om ze bij elke draai in de juiste positie te brengen.
Het aantal beurten dat nodig is om alle elementen te bestellen, is hetzelfde als in de N-1-bubbel, omdat we na elke iteratie een element op zijn plaats laten staan en dat we in de volgende beurten kunnen negeren.

We passen de sorteerfunctie echter enigszins aan om onszelf de stappen te besparen wanneer we ontdekken dat een element al is besteld:

functie sort (myArray, value1, value2) {if (value1 == value2) {return myArray; } var temp = myArray [waarde1]; myArray [waarde1] = myArray [waarde2]; myArray [waarde2] = temp; retourneer mijnArray;}

Om dit te bereiken hebben we een if-lus opgenomen waarin wordt gecontroleerd of de waarden overeenkomen, dat wil zeggen of ze al zijn besteld.

3. InvoegsorteringTen slotte zullen we het meest efficiënte algoritme van de drie zien, omdat we niet altijd N-1 iteraties nodig hebben om onze array te plaatsen, zoals we hieronder zullen zien.

Dit invoegalgoritme werkt op dezelfde manier als het plaatsen van een hand kaarten in een pokerspel terwijl de kaarten worden gedeeld.
We ordenen de kaarten meestal op kleur, en daarbinnen in oplopende volgorde als volgt:
Eerst wordt een kaart gedeeld, een enkel element dat is besteld (omdat het uniek is). Als er dan "j" -elementen zijn gerangschikt van klein naar groot, nemen we het element j + 1 en vergelijken dit met alle elementen die al zijn geordend. Als het een kleinere vindt, omdat de grotere naar rechts zijn verschoven, wordt dit element (j + 1) ingevoegd en verschuift het naar de rest.

De algoritme invoegen vertaald naar JavaScript-taal is als volgt:

functie insert (myArray) {var tam = myArray.length, temp, plaats; for (var obj = 0; obj = 0 && myArray [plaats]> temp; plaats--) {myArray [plaats + 1] = myArray [plaats]; } myArray [plaats + 1] = temp; } geef mijnArray terug;}