Golang数组如何实现stack和queue数据结构

这期内容当中小编将会给大家带来有关Golang数组如何实现stack和queue数据结构，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。

• 栈是一系列对象的组成的集合，具有先进后出的原则。

栈是最简单的数据结构也是最重要的数据结构，它的增删查看都是在栈顶操作的，它具有以下属性：

1. s.push(e) : 将一个e元素添加到栈顶；

2. s.pop(): 在stack中删除栈顶元素并且返回；

3. s.isEmpty(): 如果栈为空，返回true

4. s.len(): 返回栈的长度

5. s.top(): 返回栈顶数据

下面用数组实现栈：

package main
import (
   "errors"
   "fmt"
)

var (
   stackIsNil = errors.New("empty stack")
)

type stack []int
// Push 往stack顶部插入数据
func (s *stack) Push(e int) {
   *s = append(*s, e)
   return
}

// Pop 删除stack顶部数据并且返回删除的数据
func (s *stack) Pop() (ret int, err error) {
   if len(*s) == 0 {
      return 0, stackIsNil
   }

   temp := *s
   ret = temp[len(temp)-1]
   temp = temp[:len(temp)-1]
   *s = temp
   return
}

// IsEmpty 判断是否为空
func (s *stack) IsEmpty() bool {
   return len(*s) == 0
}

// Top 获取stack顶部数据
func (s *stack) Top() (int, error) {
   if len(*s) == 0 {
      return 0, stackIsNil
   }
   temp := *s
   return temp[len(temp)-1], nil
}

// Len 获取stack长度
func (s *stack) Len() int {
   return len(*s)
}

func main() {
   s := new(stack)
   // 插入1
   s.Push(1)
   // 插入2
   s.Push(2)
   // 插入5
   s.Push(5)
   // 获取长度
   fmt.Println(s.Len()) // 3
   // 获取stack顶部数据
   fmt.Println(s.Top()) // 5
   // 删除顶部数据
   fmt.Println(s.Pop()) // 5
   // 获取长度
   fmt.Println(s.Len()) // 2
   // 判断是否为空stack
   fmt.Println(s.IsEmpty())
}

• 队列也是一系列对象组成的集合，它具有先进先出的原则。

队列的特点是访问和删除限制在队列的第一个元素，插入被限制在队列的尾部，队列的属性：

1. q.enqueue(e): 向队列尾部插入一个元素；

2. q.dequeue(): 删除并且返回第一个元素，如果队列为空则报错；

3. q.first(): 不删除元素，直接返回第一个元素，如果为空则报错；

4. q.isEmpty(): 队列为空返回true；

5. q.len(): 返回队列长度。

数组实现队列代码：

package main
import (
   "errors"
   "fmt"
)

var (
   ErrNilQueue = errors.New("queue is nil")
)

type queue []int
// Enqueue 队列尾部插入数据
func (q *queue) Enqueue(e int) {
   *q = append(*q, e)
}

// Dequeue 队列删除第一个元素
func (q *queue) Dequeue() (ret int, err error) {
   if len(*q) == 0 {
      err = ErrNilQueue
      return
   }
   temp := *q
   ret = temp[0]
   temp = temp[1:]
   *q = temp
   return
}

// First 返回第一个数据
func (q *queue) First() (ret int, err error) {
   if len(*q) == 0 {
      err = ErrNilQueue
      return
   }
   temp := *q
   ret = temp[0]
   return
}

func (q *queue) IsEmpty() bool {
   return len(*q) == 0
}

func (q *queue) Len() int {
   return len(*q)
}

func main() {
   q := new(queue)
   q.Enqueue(1)
   q.Enqueue(10)
   q.Enqueue(20)
   fmt.Println(q.First())   // 1
   fmt.Println(q.Dequeue()) // 1
   fmt.Println(q.First())   // 10
   fmt.Println(q.IsEmpty()) // false
   fmt.Println(q.Len())     // 2
   fmt.Println(q.Dequeue()) //10
   fmt.Println(q.Len())     // 1
}

上述就是小编为大家分享的Golang数组如何实现stack和queue数据结构了，如果刚好有类似的疑惑，不妨参照上述分析进行理解。如果想知道更多相关知识，欢迎关注行业资讯频道。