✅ Enkla JavaScript -sorteringsalgoritmer

Innehållsförteckning

En algoritm är per definition en ordnad uppsättning (Det här är väldigt viktigt) systematiska operationer som gör att vi kan göra en beräkning för att hitta lösningen på alla problem av samma typ. Med andra ord är det en uppsättning instruktioner som alltid följer följande mönster:

Precision: Du måste förklara unikt och entydigt varje steg eller instruktion.
Ändlig: Antalet instruktioner som ska utföras måste begränsas.
Definition: Samma indata måste alltid ge samma utdata.
Ingång: Antalet ingångselement kan vara noll eller mer.
Upplösning: Det ska alltid ge ett resultat, vilket är utdata (er).

När en algoritm implementeras i ett visst programmeringsspråk blir det ett program som kan köras på en dator, därför kan vi säga att ett program är en algoritm eller uppsättning algoritmer skrivna på ett specifikt språk för datorn att använda. Kan tolka. I detta fall kallas detta program en beräkningsalgoritm. Å andra sidan, om det inte behöver en dator för att köra, pratar vi om icke-beräkningsalgoritmer.

I vårt fall kommer vi att prata om beräkningsalgoritmer.

Genom att veta vad en algoritm är, kommer vi att fokusera på sorteringsalgoritmerna, eller vad som är samma, algoritmen som tjänar till att sortera och returnera en lista som ursprungligen har förses med slumpmässigt placerade element som redan är beställda.
De 3 sorteringsalgoritmer mest kända är Bubbelsortera eller sortera efter bubbla, Urvalssortera eller sortera efter urval och Insättningssortera eller sortera efter infogning. Alla betraktas som enkla algoritmer eller metoder eftersom de löses med iteration eller upprepning upp till ett antal n gånger.

1. Bubbla sortera eller sortera efter bubblaSom ett exempel med en array med fyra värden, i det här fallet för enkelhetens skull kommer vi att se hur algoritmen fungerar.

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

Vi vill att du ska returnera den beställd från högsta till lägsta till exempel, det vill säga (9, 8, 7, 5, 4).

För att göra detta är det första vi måste göra att fråga de två första värdena som är det största. Om det andra värdet är större än det första, som är fallet, bör de bytas ut, å andra sidan, om de redan är beställda, lämnar vi dem som de är.
Sedan måste samma process upprepas med det andra och tredje värdet. I det här fallet är det tredje värdet större så vi skulle byta det och lämna vår array = (7, 8, 4, 5, 9).
Sedan upprepar vi föregående steg med det tredje och fjärde värdet, och åter byter vi dem. (7, 8, 5, 4, 9).
Och slutligen efter den första iterationen skulle det vara: (7, 8, 5, 9, 4).
Det är fortfarande inte beställt, men det har uppnåtts att det sista elementet, det till höger om helheten, 4, om det är beställt som det minsta antalet av alla.
I nästa omgång för att beställa vårt array är det inte längre nödvändigt att ta hänsyn till det sista eftersom vi redan vet att det är beställt, så vi skulle jämföra det första och andra elementet, sedan det andra och tredje elementet och slutligen tredje och fjärde elementet och matrisen skulle förbli: (8, 7, 9, 5, 4).
Nu är det sista och näst sista elementet sorterat.
Vi gör ytterligare en omgång där vi jämför de första och andra värdena och sedan andra och tredje och matrisen ser ut så här: (8, 9, 7, 5, 4).
De tre sista elementen är redan beställda, så det tar bara en varv till för att lämna arrayen helt ordnad: (9, 8, 7, 5, 4).

Så här burburja algoritm, som kallas så eftersom det sista elementet i varje varv stiger som en bubbla och ordnas.

Nu implementerad till JavaScript Det är väldigt enkelt:

funktionsbubbla (myArray) {var tam = myArray.length; för (var temp = 1; temp <size; temp ++) {for (var left = 0; left <(size - temp); left ++) {var right = left +1; if (myArray [vänster] <myArray [höger] {sort (myArray, vänster, höger);}}} returnera myArray;}

Vi skickar en array till vår funktion och inom den är det första vi gör att beräkna dess storlek, beräkna antalet element i arrayen.
Sedan skapar vi en yttre slinga som går igenom vår array lika många gånger som element har minus en (eftersom det är de nödvändiga tiderna för att det ska beställas helt).
Internt skapar vi en annan slinga som går igenom värdena som jämför var och en med nästa och om den till vänster är mindre än den till höger, utbyter den dem med sorteringsfunktionen som vi kommer att se nästa.
Slutligen returnerar den den ordnade matrisen.

funktionssort (myArray, värde1, värde2) {var temp = myArray [värde1]; myArray [värde1] = myArray [värde2]; myArray [värde2] = temp; returnera myArray;}

där värde1 är indexet för den första artikeln som ska bytas och värde2 är indexet för den andra posten som ska bytas.

2. UrvalssortAlgoritmen som vi kommer att se nedan flyttar inte elementen en efter en som i bubblan, utan går först igenom hela matrisen och väljer sedan rätt element för placering enligt de kriterier som vi följer (till exempel från högsta till lägsta) och den placerar den direkt i sin position, och så här får algoritmen sitt namn, väljer, tar ett element och flyttar det med en enda rörelse till sin rätta position.

I samma exempel som tidigare Array = (4, 7, 8, 5, 9) om vi vill beställa det från högsta till lägsta till exempel, först skulle vi välja 9 och sätta det i första hand och 4 skulle uppta det sista position (9, 7, 8, 5, 4). I den andra omgången skulle han välja 8: an och byta den med 7: an för att stanna i rätt position. I de följande omgångarna skulle jag inte ändra något eftersom det redan har beställts.

Koden för denna algoritm skulle vara följande:

funktionsval (myArray) {var tam = myArray.length; för (var temp = 0; temp <storlek -1; temp ++) {major = temp; för (var check = temp +1; kontrollera <size; check ++) {if (myArray [check] <myArray [major] {major = check;}} sort (myArray, major, check);} returnera myArray;}

Koden fungerar ungefär som bubblans men den yttre för slingan går igenom värdena från 0 till N-2 (de är samma antal steg som mellan 1 och N-1 som i bubblan men operationen är annorlunda ) arbetar direkt på elementen för att föra dem till rätt position vid varje varv.
Antalet varv som krävs för att alla element ska beställas är desamma som i N-1-bubblan, eftersom vi efter varje iteration lämnar ett element placerat på plats och det som vi kan ignorera i följande varv.

Vi ändrar dock sorteringsfunktionen något för att spara oss stegen när vi upptäcker att något element redan är beställt:

funktionssort (myArray, value1, value2) {if (value1 == värde2) {return myArray; } var temp = myArray [värde1]; myArray [värde1] = myArray [värde2]; myArray [värde2] = temp; returnera myArray;}

För att uppnå detta har vi inkluderat en if -loop där den kontrollerar om värdena matchar, det vill säga om de redan är beställda.

3. InsättningssorteringSlutligen kommer vi att se den mest effektiva algoritmen av de tre eftersom vi inte alltid kommer att behöva N-1 iterationer för att placera vår array som vi kommer att se nedan.

Denna insättningsalgoritm fungerar på samma sätt som att placera en hand med kort i ett pokerspel när korten delas ut.
Vi beställer vanligtvis korten efter färg, och inom dem enligt deras stigande ordning enligt följande:
Först delas ett kort ut, ett enda element som beställs (för att vara unikt). När det sedan finns ”j” -element ordnade från minst till störst tar vi elementet j + 1 och jämför det med alla element som redan är beställda. Om den hittar en mindre, eftersom de större kommer att ha flyttats till höger, sätts detta element (j + 1) in och flyttas till resten.

De infoga algoritm översatt till JavaScript -språk enligt följande:

funktionsinsats (myArray) {var tam = myArray.length, temp, place; för (var obj = 0; obj = 0 && myArray [place]> temp; place--) {myArray [place + 1] = myArray [place]; } myArray [plats + 1] = temp; } returnera myArray;}