Golang程序查找堆栈中的最小值

在Golang中，我们可以使用迭代方法和优化的迭代方法来查找堆栈中的最小值。堆栈是一种遵循后进先出（LIFO）原则的线性数据结构。

语法

func (s *Stack) getMin() int {…}

getMin（）函数用于查找堆栈中的最小值。它的参数是堆栈的地址指针。

算法

步骤1 −首先，我们需要导入fmt package。
步骤2 −创建一个带有项目片段的堆栈结构来存储堆栈元素和一个min片段来存储堆栈中的最小值。
步骤3 −现在，定义push（）和pop（）函数来执行堆栈的基本操作。
步骤4 −push（）将项目添加到堆栈的末尾，并检查项目是否小于或等于min片段中的当前最小值。如果是这样，那么项目也将添加到min片段中。
步骤5 −pop（）从堆栈中删除最后一个项目，并检查该项是否等于min片段中的最后一个项目。如果是这样，则表示min片段中的最后一个项是堆栈中的最小值，并且我们还需要从min片段中将其删除。
步骤6 −现在，创建getMin（）函数以查找堆栈中的最小值。它简单地返回min片段中的最后一个项目，表示堆栈中的最小值。
步骤7 −启动main（）函数。在main（）函数中，创建一个堆栈结构并使用一些项目初始化堆栈。
步骤8 −现在，调用getMin（）函数。
步骤9 −进一步，将堆栈中的最小值打印到控制台。

示例1

在此示例中，我们将定义一个getMin（）函数，该函数使用迭代方法查找堆栈中的最小值。

package main

import "fmt"

type Stack struct {
   items []int
   min   []int
}

func(s *Stack) push(item int) {
   s.items = append(s.items, item)
   if len(s.min) == 0 || item <= s.min[len(s.min)-1] {
      s.min = append(s.min, item)
   }
}

func(s *Stack) pop() int {
   if len(s.items) == 0 {
      return -1 // stack is empty
   }

   popped := s.items[len(s.items)-1]
   s.items = s.items[:len(s.items)-1]

   if popped == s.min[len(s.min)-1] {
      s.min = s.min[:len(s.min)-1]
   }

   return popped
}

func(s *Stack) getMin() int {
   if len(s.min) == 0 {
      return -1}

func main() {
   s := Stack{}
   s.push(5)
   s.push(2)
   s.push(7)
   s.push(1)
   s.push(8)
   fmt.Println("堆栈中的最小值为：", s.getMin()) 
   s.pop()
   s.pop()
   fmt.Println("堆栈中的最小值为：", s.getMin()) 
}

输出

堆栈中的最小值为：1
堆栈中的最小值为：2

示例2

在此示例中，我们将定义一个getMin（）函数，该函数以优化的方式使用迭代方法查找堆栈中的最小值。

包 main

import (
   "errors"
   "fmt"
)

type Stack struct {
   items []int
}

func (s *Stack) Push(item int) {
   s.items = append(s.items, item)
}

// 弹出栈顶元素并返回，如果栈为空则返回错误信息
func (s *Stack) Pop() (int, error) {
   if len(s.items) == 0 {
      return 0, errors.New("栈为空")
   }
   poppedItem := s.items[len(s.items)-1]
   s.items = s.items[:len(s.items)-1]
   return poppedItem, nil
}

// 返回栈中的最小值，如果栈为空则返回错误信息
func (s *Stack) Min() (int, error) {
   if len(s.items) == 0 {
      return 0, errors.New("栈为空")
   }
   minItem := s.items[0]
   for _, item := range s.items {
      if item < minItem {
         minItem = item
      }
   }
   return minItem, nil
}

func main() {
   stack := Stack{}
   stack.Push(4)
   stack.Push(6)
   stack.Push(2)
   stack.Push(8)
   stack.Push(1)

   // 获取栈中最小值并输出
   minItem, err := stack.Min()
   if err != nil {
      fmt.Println(err)
   } else {
      fmt.Println("栈中最小值为:", minItem)
   }
}