✅ Algoritmi di ordinamento JavaScript semplici

Sommario

Un algoritmo è per definizione un insieme ordinato (Questo è molto importante) di operazioni sistematiche che ci permette di fare un calcolo per trovare la soluzione di tutti i problemi dello stesso tipo. In altre parole, è un insieme di istruzioni che segue sempre il seguente schema:

Precisione: Devi spiegare in modo univoco e inequivocabile ogni passaggio o istruzione.
Finito: Il numero di istruzioni da eseguire deve essere limitato.
Definizione: Gli stessi dati di input devono fornire sempre le stesse informazioni di output.
Entrata: Il numero di elementi di input può essere zero o più.
Risoluzione: Dovrebbe sempre produrre un risultato, che saranno i dati di output.

Quando un algoritmo viene implementato in un certo linguaggio di programmazione diventa un programma che può essere eseguito su un computer, quindi possiamo dire che un programma è un algoritmo o un insieme di algoritmi scritti in un linguaggio specifico che il computer può interpretare. In questo caso questo programma è chiamato algoritmo di calcolo. Se invece non ha bisogno di un computer per funzionare, parliamo di algoritmi non computazionali.

Nel nostro caso parleremo di algoritmi di calcolo.

Sapendo cos'è un algoritmo, ci concentreremo sugli algoritmi di ordinamento, o che cos'è lo stesso, l'algoritmo che serve per ordinare e restituire una lista che è stata inizialmente fornita con elementi posizionati casualmente già ordinati.
Il 3 algoritmi di ordinamento i più conosciuti sono Ordina a bolle o ordina per bolla, Ordina per selezione o ordina per selezione e Ordina per inserimento o ordina per inserimento. Tutti sono considerati algoritmi o metodi semplici poiché vengono risolti per iterazione o ripetizione fino a un numero n di volte.

1. Ordina bolla o ordina per bollaPrendendo come esempio un array con quattro valori, in questo caso per semplicità quattro numeri vedremo come funziona l'algoritmo.

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

Vogliamo che tu lo restituisca ordinato dal più alto al più basso, ad esempio (9, 8, 7, 5, 4).

Per fare ciò, la prima cosa che dobbiamo fare è chiedere ai primi due valori qual è il più grande. Nel caso in cui il secondo valore sia maggiore del primo, come nel caso, dovrebbero essere scambiati, invece, se sono già ordinati, li lasciamo così come sono.
Quindi lo stesso processo dovrebbe essere ripetuto con il secondo e il terzo valore. In questo caso il terzo valore è maggiore quindi lo scambieremmo, lasciando il nostro array = (7, 8, 4, 5, 9).
Quindi ripetiamo il passaggio precedente con il terzo e il quarto valore e di nuovo li scambiamo. (7, 8, 5, 4, 9).
E infine dopo la prima iterazione sarebbe: (7, 8, 5, 9, 4).
Non è ancora ordinato, tuttavia è stato ottenuto che l'ultimo elemento, quello a destra del tutto, il 4, se è ordinato come il numero più piccolo di tutti.
Nella prossima tornata per ordinare il nostro array, non è più necessario tenere conto dell'ultimo perché sappiamo già che è ordinato, quindi confronteremo il primo e il secondo elemento, poi il secondo e il terzo elemento, e infine il terzo e quarto elemento e l'array rimarrebbe: ( 8, 7, 9, 5, 4).
Ora l'ultimo e il penultimo elemento sono ordinati.
Facciamo un altro giro confrontando il primo e il secondo valore e poi il secondo e il terzo e l'array si presenta così: (8, 9, 7, 5, 4).
Gli ultimi tre elementi sono già ordinati, quindi ci vuole solo un altro turno per lasciare l'array completamente ordinato: (9, 8, 7, 5, 4).

Ecco come algoritmo burburja, che si chiama così perché ad ogni giro l'ultimo elemento si alza come una bolla e si ordina.

Ora implementato per JavaScript È molto semplice:

funzione bolla (myArray) {var tam = myArray.length; for (var temp = 1; temp <dimensione; temp ++) {for (var sinistra = 0; sinistra <(dimensione - temp); sinistra ++) {var destra = sinistra + 1; if (myArray [left] <myArray [right] {sort (myArray, left, right);}}} return myArray;}

Passiamo un array alla nostra funzione e al suo interno la prima cosa che facciamo è calcolarne la dimensione, calcolare il numero di elementi nell'array.
Quindi creiamo un ciclo esterno che attraversa il nostro array tante volte quanti gli elementi hanno meno uno (in quanto sono i tempi necessari affinché sia completamente ordinato).
Internamente creiamo un altro loop che attraversa i valori confrontando ognuno con il successivo e se quello di sinistra è minore di quello di destra, li scambia con la funzione di ordinamento che vedremo in seguito.
Infine restituisce l'array ordinato.

funzione sort (myArray, value1, value2) {var temp = myArray [value1]; mioArray [valore1] = mioArray [valore2]; myArray [valore2] = temp; restituisce myArray;}

dove valore1 è l'indice del primo articolo da scambiare e valore2 è l'indice del secondo articolo da scambiare.

2. Ordinamento della selezioneL'algoritmo che vedremo di seguito non sposta gli elementi uno per uno come nella bolla uno, ma prima passa attraverso l'array completo e poi seleziona l'elemento corretto per il posizionamento secondo i criteri che stiamo seguendo (ad esempio, dal più alto al più basso) e lo posiziona direttamente nella sua posizione, ed è così che l'algoritmo prende il nome, selezionando, prendendo un elemento e spostandolo con un solo movimento nella sua posizione corretta.

Nello stesso esempio di prima Array = (4, 7, 8, 5, 9) se vogliamo ordinarlo dal più alto al più basso per esempio, prima dovremmo selezionare 9 e metterlo al primo posto e 4 occuperebbe l'ultimo posizione (9, 7, 8, 5, 4). Nel secondo turno avrebbe selezionato l'8 e lo avrebbe scambiato con il 7 per rimanere nella posizione corretta. Nei turni successivi non modificherei nulla in quanto è già stato ordinato.

Il codice di questo algoritmo sarebbe il seguente:

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

Il codice funziona in modo simile a quello della bolla ma il ciclo for esterno passa attraverso i valori da 0 a N-2 (sono lo stesso numero di passaggi tra 1 e N-1 come nella bolla ma l'operazione è diversa ) operando direttamente sugli elementi per portarli nella posizione corretta ad ogni svolta.
Il numero di turni necessari per ordinare tutti gli elementi è lo stesso della bolla N-1, poiché dopo ogni iterazione lasciamo un elemento posto al suo posto e quello che possiamo ignorare nei turni successivi.

Tuttavia, modifichiamo leggermente la funzione di ordinamento per risparmiarci i passaggi quando troviamo che qualche elemento è già ordinato:

funzione sort (myArray, value1, value2) {if (value1 == value2) {return myArray; } var temp = myArray [valore1]; mioArray [valore1] = mioArray [valore2]; myArray [valore2] = temp; restituisce myArray;}

Per ottenere ciò abbiamo incluso un ciclo if in cui controlla se i valori corrispondono, cioè se sono già ordinati.

3. Ordinamento di inserimentoInfine vedremo l'algoritmo più efficiente dei tre poiché non avremo sempre bisogno di N-1 iterazioni per posizionare il nostro array come vedremo di seguito.

Questo algoritmo di inserimento funziona in modo simile al piazzare una mano di carte in una partita di poker mentre le carte vengono distribuite.
Di solito ordiniamo le carte per semi e al loro interno in ordine crescente come segue:
Prima viene distribuita una carta, un singolo elemento che viene ordinato (per essere unico). Quindi quando ci sono elementi “j” ordinati dal minimo al maggiore, prendiamo l'elemento j + 1 e lo confrontiamo con tutti gli elementi che sono già ordinati. Se ne trova uno più piccolo, poiché i più grandi si saranno spostati a destra, viene inserito questo elemento (j + 1), spostandosi sul resto.

Il algoritmo di inserimento tradotto in Linguaggio JavaScript è come segue:

funzione insert (myArray) {var tam = myArray.length, temp, place; for (var obj = 0; obj = 0 && myArray [luogo]> temp; luogo--) {myArray [luogo + 1] = mioArray [luogo]; } myArray [luogo + 1] = temp; } restituisce myArray;}