数据结构
网络
关系数据库管理系统 (RDBMS)
操作系统
Java
MS Excel
iOS
HTML
CSS
Android
Python
C语言编程
C++
C#
MongoDB
MySQL
Javascript
PHP
物理学
化学
生物学
数学
英语
经济学
心理学
社会学
服装设计
法学Go语言程序反转栈
在这篇 Go 语言文章中，我们将使用递归和迭代方法反转栈。栈是一种遵循后进先出 (LIFO) 原则的线性数据结构。
算法
步骤 1 − 首先，我们需要导入 fmt 和 strconv 包。
步骤 2 − 创建一个栈结构，使用 item 切片来存储栈元素。
步骤 3 − 现在，定义函数 push()、pop()、peek()、isEmpty() 和 print() 来执行栈的基本操作。
步骤 4 − push() 将项目添加到栈的末尾，而 pop() 从栈中删除最后一个项目。peek() 返回栈中的最后一个项目，而不将其删除。
步骤 5 − isEmpty() 如果栈为空则返回 true，否则返回 false；print() 打印栈的项目。
步骤 6 − 现在，创建 reverseS() 函数来反转栈。首先，它检查栈是否为空。然后，它以反转的方式返回栈的元素。
步骤 7 − 它从栈顶弹出一个项目并将其存储在一个名为 temp 的变量中。然后，它递归调用自身以反转其余的栈。栈反转后，它调用 insert() 函数将弹出的项目插入到反转栈的底部。
步骤 8 − insert() 函数将项目插入到栈的底部。如果栈为空，它将项目压入栈并返回。
步骤 9 − 如果栈不为空，它从栈顶弹出一个项目并递归调用自身以将项目插入到底部。项目插入到底部后，它将弹出的项目压回栈中。
步骤 10 − 开始 main() 函数。在 main() 函数内，创建一个栈结构并用一些项目初始化一个栈。
步骤 11 − 打印初始栈元素。
步骤 12 − 现在，调用 reverseS() 函数并将栈作为参数传递给它。
步骤 13 − 此外，使用 print() 函数打印反转的栈元素。
示例 1
在这个例子中，我们将定义一个 reverseS() 函数，该函数用于使用递归方法反转栈。
package main
import (
"fmt"
"strconv"
)
type Stack struct {
items []int
}
func (s *Stack) push(item int) {
s.items = append(s.items, item)
}
func (s *Stack) pop() int {
l := len(s.items) - 1
item := s.items[l]
s.items = s.items[:l]
return item
}
func (s *Stack) peek() int {
return s.items[len(s.items)-1]
}
func (s *Stack) isEmpty() bool {
return len(s.items) == 0
}
func (s *Stack) print() {
for _, item := range s.items {
fmt.Print(strconv.Itoa(item) + " ")
}
fmt.Println()
}
func reverseS(s *Stack) {
if s.isEmpty() {
return
}
temp := s.pop()
reverseS(s)
insert(s, temp)
}
func insert(s *Stack, item int) {
if s.isEmpty() {
s.push(item)
return
}
temp := s.pop()
insert(s, item)
s.push(temp)
}
func main() {
s := &Stack{}
s.push(3)
s.push(6)
s.push(2)
s.push(5)
s.push(8)
fmt.Println("Initial stack:")
s.print()
reverseS(s)
fmt.Println("Updated Reversed stack:")
s.print()
}
输出
Initial stack: 3 6 2 5 8 Updated Reversed stack: 8 5 2 6 3
示例 2
在这个例子中，我们将定义一个 reverseS() 函数，该函数用于使用迭代方法反转栈。
package main
import (
"fmt"
)
type Stack struct {
items []int
}
func (s *Stack) push(item int) {
s.items = append(s.items, item)
}
func (s *Stack) pop() int {
l := len(s.items) - 1
item := s.items[l]
s.items = s.items[:l]
return item
}
func (s *Stack) peek() int {
return s.items[len(s.items)-1]
}
func (s *Stack) isEmpty() bool {
return len(s.items) == 0
}
func (s *Stack) reverseS() {
if s.isEmpty() {
return
}
stackSize := len(s.items)
for i := 0; i < stackSize/2; i++ {
temp := s.items[i]
s.items[i] = s.items[stackSize-i-1]
s.items[stackSize-i-1] = temp
}
}
func (s *Stack) print() {
for _, item := range s.items {
fmt.Printf("%d ", item)
}
fmt.Println()
}
func main() {
s := &Stack{}
s.push(6)
s.push(3)
s.push(8)
s.push(2)
s.push(9)
fmt.Println("Initial stack:")
s.print()
s.reverseS()
fmt.Println("Updated Reversed stack:")
s.print()
}
输出
Initial stack: 6 3 8 2 9 Updated Reversed stack: 9 2 8 3 6
结论
我们已经成功编译并执行了一个 Go 语言程序，该程序使用递归和迭代方法反转栈，并附带两个示例。在第一个示例中，我们使用了递归方法；在第二个示例中，我们使用了迭代方法。
172 次浏览
