Comment trier en golang

golang est un langage de programmation moderne qui a été largement utilisé dans de nombreux domaines grâce à ses capacités de concurrence et sa gestion efficace de la mémoire. En Golang, le tri est l'une des opérations courantes, et l'algorithme de tri est également une structure de données et un algorithme relativement basiques.

golang fournit certaines fonctions de tri intégrées, telles que le sort.Ints commun dans le package de tri, qui peut trier des tranches entières. De plus, nous pouvons également utiliser sort.Strings pour trier les tranches de chaîne. Mais dans certains scénarios, nous devons écrire notre propre fonction de tri pour répondre à des exigences de tri spécifiques. Dans ce cas, nous devons comprendre l'algorithme de tri et la méthode de tri fournis par golang.

1. Fonction de tri intégrée

Les fonctions de tri fournies dans Golang sont très pratiques. Par exemple, sort.Ints et sort.Strings fournis par le package de tri sont très courants. Voici un exemple d'utilisation de sort.Ints pour le tri :

package main

import (
    "fmt"
    "sort"
)

func main() {
    nums := []int{3, 2, 1, 4, 5, 7, 6}
    sort.Ints(nums)
    fmt.Println(nums)
}

Le résultat de sortie est : [1 2 3 4 5 6 7]

Nous pouvons également utiliser sort.Strings pour trier les chaînes :

package main

import (
    "fmt"
    "sort"
)

func main() {
    strs := []string{"a", "c", "b", "d", "f", "e"}
    sort.Strings(strs)
    fmt.Println(strs)
}

Le résultat de sortie est : [a b c d e f]

2. Algorithme de tri à bulles

Le tri à bulles est un algorithme de tri de base et est relativement facile à comprendre et à mettre en œuvre. Le principe de base est de comparer les éléments adjacents et d'échanger les positions si l'ordre est erroné. Après un tour de tri, la valeur maximale ou minimale atteindra la fin de la séquence. Ce processus est répété jusqu'à ce que tous les éléments soient en ordre. Voici l'algorithme de tri à bulles implémenté à l'aide de go :

package main

import "fmt"

func bubbleSort(nums []int) {
    for i := len(nums)-1; i > 0; i-- {
        for j := 0; j < i; j++ {
            if nums[j] > nums[j+1] {
                nums[j], nums[j+1] = nums[j+1], nums[j]
            }
        }
    }
}

func main() {
    nums := []int{3,2,1,4,5,7,6}
    bubbleSort(nums)
    fmt.Println(nums)
}

Le résultat de sortie est : [1 2 3 4 5 6 7]

3. Algorithme de tri rapide

Le tri rapide est un autre algorithme de tri courant. Le principe de base est Through. une passe de tri, la séquence à trier est divisée en deux parties, une partie est plus petite que l'élément de référence et l'autre partie est plus grande que l'élément de référence, puis les deux parties sont rapidement triées respectivement, et enfin un tri ordonné la séquence est obtenue. Dans le langage Go, le tri rapide est également relativement facile à mettre en œuvre. Le code est le suivant :

package main

import "fmt"

func quickSort(nums []int) []int {
    if len(nums) <= 1 {
        return nums
    }

    pivot := nums[0]
    var left, right []int
    for _, num := range nums[1:] {
        if num < pivot {
            left = append(left, num)
        } else {
            right = append(right, num)
        }
    }

    left = quickSort(left)
    right = quickSort(right)

    return append(append(left, pivot), right...)
}

func main() {
    nums := []int{3, 2, 1, 4, 5, 7, 6}
    nums = quickSort(nums)
    fmt.Println(nums)
}

Le résultat de sortie est : [1 2 3 4 5 6 7]

4. Algorithme de tri par fusion

Le tri par fusion en est un autre. algorithme de tri relativement rapide, le principe de base est de diviser la séquence à trier en deux séquences, de les trier séparément puis de les fusionner. Par rapport à l'algorithme de tri rapide, le tri par fusion ne nécessite pas d'échange d'éléments, il peut donc obtenir des résultats de tri « stables ». En golang, nous pouvons utiliser la récursion pour implémenter l'algorithme de tri par fusion. Le code est le suivant :

package main

import "fmt"

func mergeSort(nums []int) []int {
    if len(nums) <= 1 {
        return nums
    }

    mid := len(nums) / 2
    left, right := nums[:mid], nums[mid:]

    left = mergeSort(left)
    right = mergeSort(right)

    return merge(left, right)
}

func merge(left, right []int) []int {
    merged := make([]int, 0, len(left)+len(right))

    for len(left) > 0 && len(right) > 0 {
        if left[0] <= right[0] {
            merged = append(merged, left[0])
            left = left[1:]
        } else {
            merged = append(merged, right[0])
            right = right[1:]
        }
    }

    merged = append(merged, left...)
    merged = append(merged, right...)

    return merged
}

func main() {
    nums := []int{3, 2, 1, 4, 5, 7, 6}
    nums = mergeSort(nums)
    fmt.Println(nums)
}

Le résultat de sortie est : [1 2 3 4 5 6 7]

Résumé :

En golang, nous pouvons utiliser le fonction de tri intégrée pour effectuer des opérations de tri de base Pour certaines exigences de tri plus complexes, nous pouvons choisir l'algorithme de tri correspondant à mettre en œuvre en fonction de la situation spécifique. Les algorithmes de tri courants incluent le tri à bulles, le tri rapide et le tri par fusion. Lors de la mise en œuvre, il convient de prêter attention à la complexité et à la stabilité de l'algorithme.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!