Beispiele für Golang-Sortierscheiben

Beispiele Fur Golang Sortierscheiben



Sortieren ist ein grundlegender Programmiervorgang, bei dem die Elemente in eine bestimmte Reihenfolge gebracht werden. Das Sortierpaket, das die offizielle Bibliothek von Go zur Verfügung stellt, enthält mehrere Funktionen zum schnellen Sortieren der Slices. Das Sortieren von Slices ist in vielen Anwendungen eine häufige Aufgabe, von der Organisation der Daten für die Präsentation bis zur Optimierung der Suchalgorithmen. In diesem Artikel werden die verschiedenen Sortiertechniken untersucht und ihre Verwendung in Go mithilfe des Sortierpakets demonstriert.

Beispiel 1: Golang sortiert Slice in aufsteigender Reihenfolge

Die Funktion „sort.Slice()“ ist die wichtigste Funktion in Go, die die Elemente des Slice in aufsteigender oder absteigender Reihenfolge neu anordnet. Berücksichtigen Sie die folgende Abbildung, in der das Slice in aufsteigender Reihenfolge angeordnet ist:

Paket hauptsächlich
importieren (
„fmt“
'Sortieren'
)
Funktion hauptsächlich () {
EvenSlice := [] int { 10 , 2 , 8 , 4 , 0 , 6 }
fmt . Druckenln ( „Unsortierte Scheibe:“ , EvenSlice )
Sortieren . Scheibe ( EvenSlice , Funktion ( ich , J int ) bool {
zurückkehren EvenSlice [ ich ] < evenSlice [ J ]
})
fmt . Druckenln ( „Sortierte Scheibe:“ , EvenSlice )
}

Zu Beginn der main()-Funktion definieren wir das evenSlice-Slice mit den Werten {10, 2, 8, 4, 0, 6}. Dieses Slice stellt eine Sammlung gerader Zahlen dar, die zunächst unsortiert sind. Um das EvenSlice-Slice zu sortieren, wird die Funktion sort.Slice() mit dem Slice verwendet. Innerhalb der Funktion sort.Slice() wird eine Sortierfunktion als Argument bereitgestellt. Diese Funktion bestimmt die Sortierreihenfolge, indem sie die beiden Elemente des Slice an den Indizes „i“ und „j“ vergleicht. Wenn evenSlice[i] kleiner als evenSlice[j] ist, wird true zurückgegeben. andernfalls wird false zurückgegeben. Die Funktion sort.Slice() verwendet diese Vergleichsfunktion, um die Elemente des Slice „evenSlice“ in aufsteigender Reihenfolge neu anzuordnen.







Die Ergebnisse des sortierten Slice werden in aufsteigender Reihenfolge im folgenden Ausgabebildschirm generiert:





Beispiel 2: Golang Sort Part Slice

Als nächstes wird die Sortierung mithilfe der Funktion sort.Slice() in Go in aufsteigender Reihenfolge auf das Unter-Slice des angegebenen Slice angewendet.





Paket hauptsächlich
importieren (
„fmt“
'Sortieren'
)
Funktion hauptsächlich () {
N := [] int { 9 , 7 , 3 , 5 }
Start := 0
Ende := 3
Sortieren . Scheibe ( N [ Start : Ende ], Funktion ( ich , J int ) bool {
zurückkehren N [ Start + ich ] < n [ Start + J ]
})
fmt . Druckenln ( N )
}

Zunächst erstellen wir das „n“-Slice mit den Werten [9, 7, 3, 5]. Zusätzlich werden zwei Variablen, „start“ und „end“, auf 0 bzw. 3 gesetzt. Diese Variablen definieren den Bereich der Indizes im „n“-Slice, der sortiert wird. Anschließend wird die Funktion „sort.Slice()“ mit dem Sub-Slice „n[start:end]“ als erstes Argument aufgerufen. Dieses Untersegment enthält die Elemente von „n“ innerhalb des angegebenen Bereichs. Danach wird eine Sortierfunktion als zweites Argument innerhalb der Funktion sort.Slice() angegeben.

Hier erhält diese Funktion zwei Indizes, „i“ und „j“, die die Elemente innerhalb des Sub-Slices darstellen. Um die Elemente innerhalb des Sub-Slices zu vergleichen, greift die Sortierfunktion über den Start auf die entsprechenden Elemente im Original-Slice zu Offset. Es vergleicht n[start+i] und n[start+j]. Als Nächstes verwendet die Funktion sort.Slice() die bereitgestellte Sortierfunktion, um die Elemente innerhalb des Untersegments in aufsteigender Reihenfolge neu anzuordnen.



Die folgende Ausgabe zeigt, dass die Elemente innerhalb des angegebenen Bereichs (Anfang bis Ende 1) sortiert werden und die Elemente außerhalb des Bereichs unverändert bleiben:

Beispiel 3: Golang Sort Integer Slice mit der Funktion Sort.Ints()

Darüber hinaus ist die Funktion sort.Ints() die bequemste Methode zum Sortieren der Slices von Ganzzahlen, ohne dass benutzerdefinierte Sortiermethoden implementiert werden müssen. Es wirkt direkt auf ganzzahlige Slices und führt eine In-Place-Sortierung durch. Das folgende Programm sortiert die angegebenen Ganzzahlen:

Paket hauptsächlich
importieren (
„fmt“
'Sortieren'
)
Funktion hauptsächlich () {
IntSlice := [] int { 10 , 13 , fünfzehn , elf , 14 , 12 }
fmt . Druckenln ( „Unsortierte Scheibe:“ , IntSlice )
Sortieren . Ints ( IntSlice )
fmt . Druckenln ( „Sortierte Scheibe:“ , IntSlice )
}

Zuerst deklarieren und initialisieren wir das Slice „IntSlice“ mit den Werten [10, 13, 15, 11, 14, 12], die eine Sammlung von Ganzzahlen darstellen, die zunächst unsortiert sind. Dann wird die Funktion sort.Ints() mit dem „IntSlice“-Slice als Argument aufgerufen, um das „IntSlice“ zu sortieren. Die Funktion sort.Ints() sortiert in diesem Fall intern jeden Teil des Slice nach einem optimierten Sortieralgorithmus. Es ändert das Original-Slice direkt und ordnet seine Elemente in einer sortierten Reihenfolge neu an.

Die folgende Ausgabe zeigt zunächst, dass zuerst das unsortierte Slice angezeigt wird, gefolgt vom sortierten Slice:

Beispiel 4: Golang Sort String Slice

Go bietet auch die Funktion sort.Strings() des Sortierpakets an, mit der ein Teil der Zeichenfolgen in einer bestimmten Reihenfolge sortiert werden kann. Dabei hilft das folgende Programm beim Sortieren der String-Slices:

Paket hauptsächlich
importieren (
„fmt“
'Sortieren'
)
Funktion hauptsächlich () {
strSl := [] Zeichenfolge { „Golan“ , 'Python' , 'Java' , „perl“ , 'Typoskript' }
Sortieren . Saiten ( strSl )
fmt . Druckenln ( strSl )
}

Wir haben zuerst das „strSl“-Slice mit den Werten [„golang“, „python“, „java“, „perl“, „typescript“] erstellt, die nicht sortiert sind. Danach sortieren wir das „strSl“-Slice mit der Funktion sort.Strings(), die die Elemente des Slice in lexikografischer Reihenfolge sortiert. Diese Funktion ändert das Original-Slice direkt und ordnet seine Elemente basierend auf ihren ASCII-Werten in sortierter Reihenfolge neu an.

Die Ausgabe sortiert das String-Slice aufsteigend, wie im Folgenden dargestellt:

Beispiel 5: Golang Check Sort Slice mit der Funktion IntAreSort()

Mit der Funktion sort.IntsAreSorted() von Go können wir jedoch prüfen, ob ein gegebener Teil der Ganzzahlen in aufsteigender Reihenfolge sortiert ist oder nicht. Betrachten Sie das folgende Beispielprogramm der Funktion IntAreSort() für das angegebene Slice:

Paket hauptsächlich
importieren (
„fmt“
'Sortieren'
)
Funktion hauptsächlich () {
sl := [] int { - 33 , 105 , - 42 , 59 , 18 , 0 , - 3 }
fmt . Druckenln ( „Scheiben:“ )
fmt . Druckenln ( „Unsortiertes Stück:“ , sl )
Ergebnis := Sortieren . IntsAreSorted ( sl )
fmt . Druckenln ( ' \N Ergebnis:' )
fmt . Druckenln ( „Ist das angegebene Slice sortiert?:“ , Ergebnis )
}

Zunächst wird ein unsortierter Abschnitt zufälliger Ganzzahlen als „sl“ definiert. Dieses Slice enthält eine Sammlung von Ganzzahlen in keiner bestimmten Reihenfolge. Als nächstes rufen wir die Funktion sort.IntsAreSorted() auf und übergeben das „sl“-Slice als Argument. Diese Funktion liefert ein boolesches Ergebnis, das angibt, ob die Slice-Eingabe in aufsteigender Reihenfolge angeordnet ist oder nicht. Anschließend druckt die Funktion fmt.Println() die Ergebnisse aus, die basierend auf dem zurückgegebenen booleschen Wert ausgibt, ob das angegebene Slice sortiert ist oder nicht.

Die Ausgabe zeigt „false“ für die Sortierreihenfolge eines Segments von Ganzzahlen an, da es unsortiert ist:

Beispiel 6: Golang Reverse Sort Slice

Darüber hinaus können wir mithilfe der Funktionen sortReverse() und sortStringSlice() aus dem Sortierpaket in Go ein Segment von Zeichenfolgen umkehren. Das folgende Programm demonstriert die Funktionsweise der Funktion sort.Reverse():

Paket hauptsächlich
importieren (
„fmt“
'Sortieren'
)
Funktion hauptsächlich () {
Vokalscheibe := [] Zeichenfolge { 'Es ist' , 'A' , 'ich' , 'In' , 'Ö' }
fmt . Druckenln ( „Vor dem Sortieren:“ , Vokalscheibe )
Sortieren . Sortieren ( Sortieren . Umkehren ( Sortieren . StringSlice ( Vokalscheibe )))
fmt . Druckenln ( „Nach dem Sortieren:“ , Vokalscheibe )
}

Wir beginnen mit der Definition eines Abschnitts der Zeichenfolge „vowelSlice“, der die Vokale „e“, „a“, „i“, „u“ und „o“ enthält. Der anfängliche Inhalt des angegebenen String-Slices wird zuerst mit der Funktion „print“ gedruckt. Als nächstes wird der Sortiervorgang mithilfe der Funktion sort.Sort() mit den Funktionen sort.Reverse() und sort.StringSlice() als Argumente durchgeführt. Hier erstellt „sort.Reverse()“ einen neuen Typ, der die Reihenfolge der Elemente umkehrt. Als Argument wird der Typ „sort.StringSlice“ verwendet, der den VowelSlice in einen sortierbaren Typ umwandelt.

Die Ausgabe hier zeigt die Vokale in umgekehrter alphabetischer Reihenfolge an:

Abschluss

Wir haben uns anhand von Beispielen mit verschiedenen Sortierfunktionen befasst, die das bereitgestellte Slice sortieren. Wir haben uns auch mit der Sortierung von Sub-Slices und der Prüfung, ob ein Slice bereits sortiert ist, befasst. Daher können wir die Fähigkeiten des Sortierpakets nutzen, um eine Vielzahl von Sortierherausforderungen in ihren Go-Projekten zu bewältigen.