So implementieren Sie die Sortierung in der Go-Sprache

In den letzten Jahren hat sich die Go-Sprache zu einer sehr beliebten Programmiersprache entwickelt, insbesondere in der Webentwicklung und bei Cloud-nativen Anwendungen. Immer mehr Entwickler haben sich für die Go-Sprache entschieden. Unter anderem ist die Sortierfunktion in der Go-Sprache äußerst leistungsfähig und kann problemlos verschiedene Sortierfunktionen implementieren. In diesem Artikel erfahren Sie, wie Sie die Sortierung in der Go-Sprache implementieren.

1. Sortieren in Golang

Die Go-Sprache stellt das Sortierpaket zur Implementierung verschiedener Sortieralgorithmen bereit. Lassen Sie uns die beiden Hauptfunktionen im Sortierpaket vorstellen. Die Funktion

1. sort.Slice

sort.Slice kann zum Sortieren von Daten vom Typ Slice verwendet werden. Der Funktionsprototyp lautet wie folgt:

func Slice(slice interface{}, less func(i, j int) bool)

Unter diesen stellt der Parameter slice den Slice dar Das muss sortiert werden, der Parameter less ist eine Beurteilungsfunktion und der Rückgabewert muss vom Typ bool sein. Die Beurteilungsfunktion less wird verwendet, um die Größenbeziehung jedes Elements im Slice zu bestimmen. Wenn true zurückgegeben wird, bedeutet dies, dass das vordere Element kleiner als das hintere Element ist und ausgetauscht werden muss. slice参数表示需要排序的切片，less参数是一个判断函数，返回值必须是bool类型。判断函数less用于判定切片中每个元素的大小关系，如果返回true代表前面的元素比后面的元素小，需要交换位置。

以排序int类型的切片为例，示例代码如下：

package main

import (
    "fmt"
    "sort"
)

func main() {
    ints := []int{3, 1, 4, 1, 5, 9, 2, 6, 5, 4}
    sort.Slice(ints, func(i, j int) bool {
        return ints[i] < ints[j]
    })
    fmt.Println(ints)
}

上面的程序可以对一个int类型的切片进行排序，结果将按照从小到大的顺序排列。

2. sort.Sort

sort.Sort函数可以用来排序实现了sort.Interface接口的类型，其函数原型如下：

func Sort(data Interface)

其中，data

Nehmen Sie das Sortieren von Slices vom Typ int als Beispiel. Der Beispielcode lautet wie folgt:

type Interface interface {
    Len() int
    Less(i, j int) bool
    Swap(i, j int)
}

Das obige Programm kann ein Slice vom Typ int sortieren und die Ergebnisse werden in der Reihenfolge von klein nach groß angeordnet.

sort.Sort

sort.Sort-Funktion kann zum Sortieren von Typen verwendet werden, die die sort.Interface-Schnittstelle implementieren. Der Funktionsprototyp lautet wie folgt:

package main

import (
    "fmt"
    "sort"
)

type stringSlice []string

func (s stringSlice) Len() int {
    return len(s)
}

func (s stringSlice) Less(i, j int) bool {
    return s[i] < s[j]
}

func (s stringSlice) Swap(i, j int) {
    s[i], s[j] = s[j], s[i]
}

func main() {
    words := stringSlice{"foo", "bar", "baz", "qux"}
    sort.Sort(words)
    fmt.Println(words)
}

Darunter der Parameter data Stellt die Daten dar, die sortiert werden müssen. Dieser Parameter muss ein Typ sein, der die Schnittstelle sort.Interface implementiert. Die Definition der Schnittstelle sort.Interface lautet wie folgt:

package main

import "fmt"

func quickSort(arr []int, left, right int) {
    if left < right {
        partIndex := partition(arr, left, right)
        quickSort(arr, left, partIndex-1)
        quickSort(arr, partIndex+1, right)
    }
}

func partition(arr []int, left, right int) int {
    pivot := left
    for i:= left + 1; i <= right; i++ {
        if arr[i] < arr[left] {
            pivot++
            arr[pivot], arr[i] = arr[i], arr[pivot]
        }
    }
    arr[left], arr[pivot] = arr[pivot], arr[left]
    return pivot
}

func main() {
    arr := []int{5, 0, 3, 2, 1, 6, 8, 9, 7, 4}
    quickSort(arr, 0, len(arr)-1)
    fmt.Println(arr)
}

1. sort.Interface definiert drei zum Sortieren erforderliche Funktionen: Len() gibt die Datenlänge zurück und Less(i, j int) wird verwendet, um zu bestimmen, ob sich die Daten an der Position befinden i ist kleiner als die an Position j. Data, Swap(i, j int) tauscht die Daten an Position i mit den Daten an Position j aus.

Nehmen Sie das Sortieren eines String-Arrays als Beispiel. Der Beispielcode lautet wie folgt:

package main

import "fmt"

func shellSort(arr []int) []int {
    n := len(arr)
    for gap := n / 2; gap > 0; gap /= 2 {
        for i := gap; i < n; i++ {
            for j := i - gap; j >= 0 && arr[j] > arr[j+gap]; j -= gap {
                arr[j], arr[j+gap] = arr[j+gap], arr[j]
            }
        }
    }
    return arr
}

func main() {
    arr := []int{5, 0, 3, 2, 1, 6, 8, 9, 7, 4}
    fmt.Println(shellSort(arr))
}

Das obige Programm kann ein String-Array sortieren und die Ergebnisse werden in der Reihenfolge von klein nach groß angeordnet.

• 2. Implementierung gängiger Sortieralgorithmen
• Im Sortierpaket sind gängige Sortieralgorithmen implementiert, z. B. Schnellsortierung, Hill-Sortierung usw. Diese Algorithmen werden basierend auf der sort.Interface-Schnittstelle implementiert Zusätzlich zu den vom Sortierpaket bereitgestellten Funktionen können Sie auch Ihren eigenen Sortieralgorithmus implementieren.
• Schnellsortierung

Schnellsortierung verwendet die Divide-and-Conquer-Strategie, um eine Sequenz in zwei Teilsequenzen zu teilen. Der spezifische Prozess ist wie folgt:

2. Wählen Sie ein Element aus der Sequenz als Basiszahl aus.

Platzieren Sie alle Elemente, die kleiner als die Basiszahl sind, vor der Basiszahl und platzieren Sie Elemente, die größer als die Basiszahl sind, nach der Basiszahl.

Wiederholen Sie die obigen Schritte für die beiden Teilsequenzen vor und nach der Referenznummer.

Das Folgende ist ein Beispielcode für die schnelle Sortierung:

rrreee

🎜Hill-Sortierung🎜🎜🎜Hill-Sortierung, auch bekannt als absteigender inkrementeller Sortieralgorithmus, ist eine effizientere Implementierung der Einfügungssortierung, die die zu sortierenden Elemente kombiniert In mehrere Gruppen aufteilen und jeweils eine Einfügungssortierung durchführen. Die endgültige Sortierung wird durch schrittweises Reduzieren der Anzahl der Gruppen und Erhöhen des Abstands der Elemente innerhalb der Gruppen abgeschlossen. 🎜🎜Das Folgende ist ein Beispielcode für die Hill-Sortierung: 🎜rrreee🎜 3. Zusammenfassung 🎜🎜In diesem Artikel werden die Methoden und häufig verwendeten Sortieralgorithmen zur Implementierung der Sortierung in der Go-Sprache vorgestellt. Die Schnellsortierung und die Hill-Sortierung gehören zu den am häufigsten verwendeten Sortieralgorithmen sind relativ effiziente Implementierungsmethoden. Bei Verwendung des Sortierpakets müssen Entwickler die drei Methoden von sort.Interface überschreiben. Für einige komplexere Datenstrukturen können sie auch einen eigenen Sortieralgorithmus implementieren, um den Sortiervorgang abzuschließen. 🎜

Das obige ist der detaillierte Inhalt vonSo implementieren Sie die Sortierung in der Go-Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!