Esempi di fette di ordinamento di Golang

Esempi Di Fette Di Ordinamento Di Golang



L'ordinamento è un'operazione di programmazione fondamentale che include l'inserimento degli elementi in un ordine particolare. Il pacchetto sort, in cui la libreria ufficiale di Go mette a disposizione, include diverse funzioni per ordinare velocemente le slice. L'ordinamento delle sezioni è un'attività comune in molte applicazioni, dall'organizzazione dei dati per la presentazione all'ottimizzazione degli algoritmi di ricerca. Questo articolo esplora le diverse tecniche di ordinamento e ne dimostra l'utilizzo in Go utilizzando il pacchetto sort.

Esempio 1: Golang Sort Slice in ordine crescente

La funzione 'sort.Slice()' è la funzione principale in Go che riorganizza gli elementi della sezione in ordine crescente o decrescente. Prendere in considerazione la seguente illustrazione in cui la sezione è disposta in ordine crescente:

pacchetto principale
importare (
'fmt'
'ordinare'
)
funz principale () {
evenSlice := [] int { 10 , 2 , 8 , 4 , 0 , 6 }
fmt . Stampaln ( 'Fetta non ordinata:' , evenSlice )
ordinare . Fetta ( evenSlice , funz ( io , J int ) bool {
ritorno evenSlice [ io ] < evenSlice [ J ]
})
fmt . Stampaln ( 'Fetta ordinata:' , evenSlice )
}

All'inizio della funzione main(), definiamo la slice evenSlice con i valori {10, 2, 8, 4, 0, 6}. Questa sezione rappresenta una raccolta di numeri pari inizialmente non ordinati. Per ordinare la sezione evenSlice, viene utilizzata la funzione sort.Slice() con la sezione. All'interno della funzione sort.Slice(), viene fornita una funzione di ordinamento come argomento. Questa funzione determina l'ordine di ordinamento confrontando i due elementi della fetta agli indici “i” e “j”. Se evenSlice[i] è minore di evenSlice[j], restituisce true; in caso contrario, restituisce false. La funzione sort.Slice() utilizza questa funzione di confronto per riorganizzare gli elementi della sezione 'evenSlice' in ordine crescente.







I risultati della sezione ordinata in ordine crescente vengono generati nella seguente schermata di output:





Esempio 2: Golang Sort Part Slice

Successivamente, l'ordinamento viene applicato alla sottosezione della sezione specificata in ordine crescente utilizzando la funzione sort.Slice() in Go.





pacchetto principale
importare (
'fmt'
'ordinare'
)
funz principale () {
N := [] int { 9 , 7 , 3 , 5 }
inizio := 0
FINE := 3
ordinare . Fetta ( N [ inizio : FINE ], funz ( io , J int ) bool {
ritorno N [ inizio + io ] < n [ inizio + J ]
})
fmt . Stampaln ( N )
}

Inizialmente, creiamo la sezione 'n' con i valori [9, 7, 3, 5]. Inoltre, due variabili, 'start' e 'end', sono impostate rispettivamente su 0 e 3. Queste variabili definiscono l'intervallo di indici nella sezione 'n' che verrà ordinata. La funzione 'sort.Slice()' viene quindi chiamata con la sub-slice 'n[start:end]' come primo argomento. Questa sezione secondaria contiene gli elementi di 'n' all'interno dell'intervallo specificato. Successivamente, viene fornita una funzione di ordinamento come secondo argomento all'interno della funzione sort.Slice().

Qui, quella funzione riceve due indici, 'i' e 'j', che rappresentano gli elementi all'interno della sottosezione. Per confrontare gli elementi all'interno della sottosezione, la funzione di ordinamento accede agli elementi corrispondenti nella sezione originale utilizzando l'inizio offset.Confronta n[start+i] e n[start+j].Successivamente, la funzione sort.Slice() utilizza la funzione di ordinamento fornita per riorganizzare gli elementi all'interno della sub-slice in ordine crescente.



Il seguente output mostra che gli elementi all'interno dell'intervallo specificato (dall'inizio alla fine-1) sono ordinati e gli elementi al di fuori dell'intervallo rimangono invariati:

Esempio 3: Golang Sort Integer Slice utilizzando la funzione Sort.Ints()

Inoltre, la funzione più comoda per ordinare le fette di interi è la funzione sort.Ints() senza la necessità di implementare i metodi di ordinamento personalizzati. Agisce direttamente sulle fette intere ed esegue un ordinamento sul posto. Il seguente programma ordina gli interi specificati:

pacchetto principale
importare (
'fmt'
'ordinare'
)
funz principale () {
IntSlice := [] int { 10 , 13 , quindici , undici , 14 , 12 }
fmt . Stampaln ( 'Fetta non ordinata:' , IntSlice )
ordinare . Int ( IntSlice )
fmt . Stampaln ( 'Fetta ordinata:' , IntSlice )
}

Innanzitutto, dichiariamo e inizializziamo la sezione 'IntSlice' con i valori [10, 13, 15, 11, 14, 12] che rappresentano una raccolta di numeri interi inizialmente non ordinati. Quindi, la funzione sort.Ints() viene chiamata con la sezione 'IntSlice' come argomento per ordinare 'IntSlice'. La funzione sort.Ints() in questo caso ordina internamente ogni parte della slice secondo un algoritmo di ordinamento ottimizzato. Modifica direttamente la sezione originale, riorganizzando i suoi elementi in un ordine ordinato.

Il seguente output mostra innanzitutto che la sezione non ordinata viene visualizzata per prima, seguita dalla sezione ordinata:

Esempio 4: Golang Sort String Slice

Go offre anche la funzione sort.Strings() del pacchetto sort che viene utilizzato per ordinare una porzione di stringhe in un ordine specifico. Qui, il seguente programma aiuta a ordinare la fetta di stringhe:

pacchetto principale
importare (
'fmt'
'ordinare'
)
funz principale () {
strSl := [] corda { 'golan' , 'pitone' , 'Giava' , 'perla' , 'dattiloscritto' }
ordinare . stringhe ( strSl )
fmt . Stampaln ( strSl )
}

Per prima cosa abbiamo stabilito la slice 'strSl' con i valori ['golang', 'python', 'java', 'perl', 'typescript'] che non sono ordinati. Successivamente, ordiniamo la slice “strSl” con la funzione sort.Strings() che ordina gli elementi della slice in ordine lessicografico. Questa funzione modifica direttamente la sezione originale, riordinando i suoi elementi in base ai loro valori ASCII.

L'output ordina la porzione di stringa in modo crescente come visualizzato di seguito:

Esempio 5: sezione di ordinamento del controllo Golang utilizzando la funzione IntAreSort()

Tuttavia, con la funzione sort.IntsAreSorted() di Go, possiamo verificare se una data porzione di numeri interi è ordinata in ordine crescente o meno. Si consideri il seguente programma di esempio della funzione IntAreSort() per la slice data:

pacchetto principale
importare (
'fmt'
'ordinare'
)
funz principale () {
sl := [] int { - 33 , 105 , - 42 , 59 , 18 , 0 , - 3 }
fmt . Stampaln ( 'Fette:' )
fmt . Stampaln ( 'Sezione non ordinata: ' , sl )
risultato := ordinare . IntsAreSorted ( sl )
fmt . Stampaln ( ' \N Risultato:' )
fmt . Stampaln ( 'Viene dato Slice ordinato?: ' , risultato )
}

Innanzitutto, una fetta non ordinata di numeri interi casuali è definita come 'sl'. Questa sezione contiene una raccolta di numeri interi senza un ordine particolare. Successivamente, chiamiamo la funzione sort.IntsAreSorted() e passiamo la slice 'sl' come argomento. Questa funzione fornisce un risultato booleano che indica se l'input della sezione è disposto o meno in ordine crescente. Quindi, la funzione fmt.Println() stampa i risultati che indicano se la sezione data è ordinata o meno in base al valore booleano restituito.

L'output visualizza false per l'ordinamento di una porzione di numeri interi poiché non è ordinato:

Esempio 6: Golang Reverse Sort Slice

Inoltre, utilizzando le funzioni sortReverse() e sortStringSlice() dal pacchetto sort in Go, possiamo eseguire l'ordinamento inverso di una porzione di stringhe. Il seguente programma mostra il funzionamento della funzione sort.Reverse():

pacchetto principale
importare (
'fmt'
'ordinare'
)
funz principale () {
vocaleSlice := [] corda { 'È' , 'UN' , 'io' , 'In' , 'Oh' }
fmt . Stampaln ( 'Prima dell'ordinamento :' , vocaleSlice )
ordinare . Ordinare ( ordinare . Inversione ( ordinare . StringSlice ( vocaleSlice )))
fmt . Stampaln ( 'Dopo l'ordinamento:' , vocaleSlice )
}

Iniziamo definendo una sezione della stringa 'vowelSlice' che contiene le vocali 'e', 'a', 'i', 'u' e 'o'. Il contenuto iniziale della porzione di stringhe specificata viene stampato per primo utilizzando la funzione 'print'. Successivamente, l'operazione di ordinamento viene eseguita utilizzando la funzione sort.Sort() con le funzioni sort.Reverse() e sort.StringSlice() come argomenti. Qui, 'sort.Reverse()' crea un nuovo tipo che inverte l'ordine degli elementi. Prende il tipo 'sort.StringSlice' come argomento che converte la vocaleSlice in un tipo ordinabile.

L'output qui mostra le vocali in ordine alfabetico inverso:

Conclusione

Abbiamo approfondito varie funzioni di ordinamento con esempi che ordinano la sezione fornita. Abbiamo anche parlato dell'ordinamento delle sezioni secondarie e del controllo se una sezione è già ordinata. Quindi, possiamo sfruttare le capacità del pacchetto di smistamento per affrontare un'ampia gamma di sfide di smistamento nei loro progetti Go.