Cara menyusun dalam golang

Golang ialah bahasa pengaturcaraan moden yang telah digunakan secara meluas dalam pelbagai bidang melalui keupayaan konkurensi dan pengurusan memori yang cekap. Dalam golang, pengisihan adalah salah satu operasi biasa, dan algoritma pengisihan juga merupakan struktur dan algoritma data yang agak asas.

golang menyediakan beberapa fungsi pengisihan terbina dalam, seperti isihan biasa. Ints dalam pakej isihan, yang boleh mengisih hirisan integer. Selain itu, kita juga boleh menggunakan sort.Strings untuk mengisih kepingan rentetan. Tetapi dalam beberapa senario, kita perlu menulis fungsi pengisihan kita sendiri untuk memenuhi keperluan pengisihan tertentu Dalam kes ini, kita perlu memahami algoritma pengisihan dan kaedah pengisihan yang disediakan oleh golang.

1. Fungsi pengisihan terbina dalam

Fungsi pengisihan yang disediakan dalam golang adalah sangat mudah biasa. Berikut ialah contoh penggunaan sort.Ints untuk mengisih:

package main

import (
    "fmt"
    "sort"
)

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

Hasil output ialah: [1 2 3 4 5 6 7]

Kita juga boleh menggunakan sort.Strings untuk mengisih rentetan :

package main

import (
    "fmt"
    "sort"
)

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

Hasil keluarannya ialah: [a b c d e f]

2. Algoritma isihan buih

Isih buih ialah algoritma pengisihan asas dan perbandingan Mudah difahami dan melaksanakan. Prinsip asas adalah untuk membandingkan elemen bersebelahan, dan menukar kedudukan jika susunannya salah Selepas satu pusingan pengisihan, nilai maksimum atau minimum akan mencapai penghujung jujukan, dan proses ini diulang sehingga semua elemen adalah teratur. Berikut ialah algoritma isihan gelembung yang dilaksanakan menggunakan 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)
}

Hasil output ialah: [1 2 3 4 5 6 7]

3. Algoritma isihan pantas

Isih cepat ialah satu lagi algoritma pengisihan biasa. Prinsip asasnya ialah membahagikan urutan untuk diisih kepada dua bahagian melalui satu laluan pengisihan Satu bahagian lebih kecil daripada elemen rujukan, bahagian lain lebih besar daripada elemen rujukan. dan kemudian kedua-dua bahagian cepat diproses secara berasingan dan akhirnya mendapat urutan yang dipesan. Dalam bahasa Go, pengisihan pantas juga agak mudah untuk dilaksanakan Kodnya adalah seperti berikut:

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)
}

Hasil output ialah: [1 2 3 4 5 6 7]

4. Algoritma isihan gabungan

Isih gabung ialah satu lagi algoritma pengisihan yang agak pantas Prinsip asasnya ialah membahagikan urutan untuk diisih kepada dua jujukan, mengisihnya secara berasingan dan kemudian menggabungkannya. Berbanding dengan algoritma isihan pantas, isihan gabungan tidak memerlukan pertukaran elemen, jadi ia boleh mencapai hasil pengisihan "stabil". Dalam golang, kita boleh menggunakan rekursi untuk melaksanakan algoritma isihan gabungan Kodnya adalah seperti berikut:

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)
}

Hasil output ialah: [1 2 3 4 5 6 7]

Ringkasan:

Dalam golang, kita boleh menggunakan fungsi isihan terbina dalam untuk melaksanakan operasi pengisihan asas Untuk beberapa keperluan pengisihan yang lebih kompleks, kita boleh memilih algoritma pengisihan yang sepadan untuk dilaksanakan mengikut situasi tertentu. Algoritma pengisihan biasa termasuk pengisihan gelembung, pengisihan cepat dan pengisihan Apabila melaksanakan, perhatian harus diberikan kepada kerumitan dan kestabilan algoritma.

Atas ialah kandungan terperinci Cara menyusun dalam golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!