日本免费高清视频-国产福利视频导航-黄色在线播放国产-天天操天天操天天操天天操|www.shdianci.com

學無先后，達者為師

網站首頁 編程語言 正文

詳解Go語言如何實現字符串切片反轉函數_Golang

作者：宇宙之一粟 ? 更新時間： 2022-11-27 編程語言

Python 中的 reverse 函數

Go 語言不像其他語言如 Python，有著內置的 reverse() 函數，先來看一下 Python 中對于列表的反轉方法，然后我們再來學習如果在 Go 語言中實現相同的功能。

>>> myList = [2022, 2021, 2008, 2012]
>>> myList.reverse()
>>> print("Reversed List:", myList)
Reversed List: [2012, 2008, 2021, 2022]
>>>

實現一個 reverse 反轉函數

reverse 算法取一個數據集，并將該數據集的值進行反轉，Go 標準的 sort 包并沒有內置的方法來反轉一個切片。

利用兩個切片實現

設計思想：

  • 確定切片長度
  • 獲取最后一個元素
  • 以相反的順序在新切片中添加最后一個元素到第一個位置
package main

import "fmt"

func main() {
    s := []string{"hello", "foo", "bar", "go", "abc", "zzz"}

    // 定義新的反轉切片
    reverseOfS := []string{}

    // 遍歷原切片 s
    for i := range s {
        reverseOfS = append(reverseOfS, s[len(s)-1-i])
    }
    fmt.Println(reverseOfS)
}

運行結果：

[zzz abc go bar foo hello]

顯然，這種方式會額外花費一個相同空間的切片，空間復雜度為 O(n)。

前后兩兩原地交換

我們可以寫一個簡易的 reverse 函數來進行數據的反轉，通過循環原切片的一半，然后依次與對應的元素進行交換，比如：：

func reverse(s []string) []string {
    for i := 0; i < len(s)/2; i++ {
        j := len(s) - i - 1
        s[i], s[j] = s[j], s[i]
    }
    return  s
}

這個函數可以通過更簡短的實現，通過 Go 內部的操作進行循環：

package main

import "fmt"

func reverse(s []string) []string {
    for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
        s[i], s[j] = s[j], s[i]
    }
    return s
}

func main() {
    s := []string{"hello", "foo", "bar", "go", "abc", "zzz"}

    reverseOfS := reverse(s)

    fmt.Println(reverseOfS)
}

執行結果：

[zzz abc go bar foo hello]

但是，上面的 reverse 函數都是通過切片按值傳遞，其實我們在修改傳遞中的 []string 切片，實際上，可以通過以下方式進一步簡寫：

package main

import "fmt"

func reverse(s []string) {
    for i := 0; i < len(s)/2; i++ {
        j := len(s) - i - 1
        s[i], s[j] = s[j], s[i]
    }
}

func main() {
    s := []string{"hello", "foo", "bar", "go", "abc", "zzz"}

    reverse(s)
    fmt.Printf("%v\n", s)
}

此時，reverse() 函數不會返回切片的另一個引用，此時的交換就是就地進行，此時更像文章開頭 Python 中的 reverse() 函數。

反轉為原切片的副本

如果我們要返回切片的反轉的副本，reverse 函數就可以這樣寫：

package main

import "fmt"

func reverse(s []string) []string {

    newS := make([]string, len(s))
    for i, j := 0, len(s)-1; i <= j; i, j = i+1, j-1 {
        newS[i], newS[j] = s[j], s[i]
    }
    return newS
}

func main() {
    s := []string{"hello", "foo", "bar", "go", "abc", "zzz"}

    fmt.Printf("原字符串切片：%v\n", s)
    fmt.Printf("反轉后的切片：%v\n", reverse(s))
}

運行結果：

原字符串切片：[hello foo bar go abc zzz]
反轉后的切片：[zzz abc go bar foo hello]

可以看到，原切片是沒有變化的。

當然，因為我們沒有就地修改原切片，因此又可以回到最初的方法 append，看代碼：

func reverse(s []string) []string {

    newS := make([]string, 0, len(s))

    for i := len(s)-1; i >= 0; i-- {
        newS = append(newS, s[i])
    }
    return newS
}

運行結果圖如下：

總結

本文通過 Python 中的 reverse() 函數的一個示例，引發出一個思考：Go 語言中有沒有類似的反轉函數？

然后通過幾種方式實現同樣的字符串切片的反轉功能，并通過借助額外空間和就地反轉兩種方式實現了功能相同 reverse 函數，其實類似的反轉思想也可以用于字符串或者鏈表反轉等其他數據結構。

原文鏈接：https://juejin.cn/post/7155384011089510407

欄目分類
最近更新