Golang程序 使用堆栈反转字符串

在这篇文章中，我们将看到如何用Go编程的堆栈来反转一个字符串。栈是Go中符合后进先出（LIFO）的数据结构。这意味着第一个被消除的元素将是最近添加到堆栈中的元素。双链列表在Go的内置包 “container/list “中实现，可以用来建立一个堆栈。不过在Go中经常使用Slices（动态数组）来实现堆栈。让我们用不同的例子集来看看它是如何执行的。

方法一：将字符串转换为符文片断

在这个方法中，我们将看到如何通过将字符串转换为符文片来使用堆栈逆转字符串。符文相当于Go的字符，因此它首先将字符串切成符文，然后将每个符文推入堆栈。下一步是将每个符文从堆栈中移除，并将其添加到一个新的字符串中。结果，原来的字符串被转过来。然后，main函数对一个字符串使用反转函数，它同时打印出原始字符串和反转后的字符串。让我们看看它的执行情况。

语法

func append(slice, element_1, element_2…, element_N) []T

append函数用于向一个数组片断添加值。它需要一些参数。第一个参数是我们希望添加的数组，后面是要添加的值。然后，该函数返回包含所有值的数组的最终片断。

算法

• 第1步 – 创建一个包main，并在程序中声明fmt(format package)包，其中main产生可执行的Example:s，fmt帮助格式化输入和输出。

• 第2步 – 创建一个函数reverse，用一个变量来存储反转的字符串，用一个空栈来存放它。

• 第 3步– 将输入到函数中的字符串转化为符文片断。

• 第 4步– 每次将符文片中的每个符文推到堆栈中。

• 第 5步– 从堆栈中弹出每个符文，并在你通过抽签时将其添加到反转的字符串中。

• 第6步 – 返回被反转的字符串作为结果。

• 第7步 – 从主函数中调用函数reverse，参数为要反转的字符串。

• 第8步 – 使用fmt.Println()函数将反转的字符串打印到控制台，其中ln表示新行。

例子

在下面的例子中，我们将通过将字符串转换为符文片来逆转字符串。

package main
import (
   "fmt"
)

func reverse(str string) string {
   runes := []rune(str)   //convert the string to slice of runes
   var stack []rune
   for _, v := range runes {
      stack = append(stack, v)     //push rune in the slice 
   }
   var reversed string
   for i := len(stack) - 1; i >= 0; i-- {
      reversed += string(stack[i])
   }
   return reversed     //return reversed string
}

func main() {
   original := "Hello, alexa!"
   fmt.Println("The original string given here is:", original)
   reversed := reverse(original)
   fmt.Println("The reversed string here is:", reversed) //print reversed string
}

输出

The original string given here is: Hello, alexa!
The reversed string here is: !axela ,olleH

方法2：在实例中借助结构使用堆栈

在这个方法中，我们将使用结构来反转一个字符串。上述程序中使用了Stack结构，该结构实现了Push和Pop方法来添加和删除堆栈中的项目。在主函数中，在创建Stack结构的一个实例后，使用for循环将输入字符串的每个字符放入堆栈。使用第二个for循环将每个字符从堆栈中取出，添加到一个新的字符串中，然后打印成倒置的字符串。让我们来看看它的执行情况。

算法

• 第1步 – 创建一个包main，并在程序中声明fmt(format package)包，其中main产生可执行实例，fmt帮助格式化输入和输出。

• 第2步 – 将Push和Pop函数纳入一个名为Stack的结构中，分别从堆栈中添加和删除东西。

• 第 3步– 在main函数中初始化一个Stack结构实例，并接受一个需要反转的字符串作为输入。

• 第4步 – 使用推送技术将输入字符串的每个字符推送到堆栈中，使用for循环。

• 第5步– 创建一个名字反转的空白字符串。

• 第6步 – 使用第二个for循环将每个字符添加到反转的字符串中，使用Pop函数将它们从堆栈中移除。

• 第 7步 – 使用fmt.Println()函数打印反转的字符串作为输出，其中ln表示新行。

• 第8步– 由于我们对字符串进行了两次迭代，一次是将字符放在堆栈中，一次是从堆栈中弹出，这种方法的总体时间复杂度是O(n)，其中n是输入字符串的长度。由于使用了第二个堆栈来保存字符，这种技术的空间复杂度也是O(n)。

例子

在下面的例子中，我们将在例子中的结构的帮助下，通过使用堆栈来逆转字符串

package main
import "fmt"

type Stack struct { // Stack struct
   items []rune
}

func (str *Stack) Push(item rune) { //push method to items in stack
   str.items = append(str.items, item)
}

func (str *Stack) Pop() rune { //pop method to pop items from the stack
   item := str.items[len(str.items)-1]
   str.items = str.items[:len(str.items)-1]
   return item
}

func main() {
   stack := &Stack{}   //create a stack
   str := "hello alexa"  //create a string
   fmt.Println("The original string is:", str)  
   for _, char := range str {
      stack.Push(char)
   }
   reversed := ""  //create empty string to add reversed string
   for i := 0; i < len(str); i++ {
      reversed += string(stack.Pop())  //pop items from stack and add to newly created string
   }
   fmt.Println("The reversed string is:")
   fmt.Println(reversed) // Output: "dlrow olleh"
}

输出

The original string is: hello alexa
The reversed string is:
axela olleh

总结

我们在不同例子的帮助下执行了使用堆栈反转字符串的程序。在第一个例子中，我们将字符串转换为符文片，在第二个方法中，我们使用结构来执行该函数。