Golang练习用的队列

package main

import (
   "fmt"
)
/***
 * 构造节点，用接口类型，可以
 * 入队列,出队列任意类型
 */
type Item interface {

}

/***
 * 定义队列链
 */ 
type ItemQueue struct{
   items []Item
}

/***
 * 定义队列链接口
 */ 
type QueueIterface interface {
   Init() ItemQueue
   Push(t Item) ItemQueue
   Pop() *Item
   IsEmpty() bool
   Size() int
}

/***
 * 初始化队列
 */
func (s *ItemQueue) Init() *ItemQueue{
   s.items = []Item{}
   return s
}

/***
 * 入队列
 */
func (s *ItemQueue) Push(t Item) *ItemQueue{
   //append方法可以动态改变数组的长度
   s.items = append(s.items,t)
   return s
}

/***
 * 出队列
 */
func (s *ItemQueue) Pop() *Item{
   //获取队列顶端的数据
   item := s.items[0]
   //改变队列长度 
   s.items = s.items[1:len(s.items)]
   return &item
}

func (s *ItemQueue) IsEmpty() bool{
   return len(s.items) == 0
}

func (s *ItemQueue) Size() int{
   return len(s.items)
}

type Node struct {
   index int
   data  string
}



func main()  {
   var queue ItemQueue
   if queue.items == nil{
      itemQueu := ItemQueue{}
      queue = *itemQueu.Init()
   }

   intf := func(val interface{})(item int,res bool){
        //断言判断是否是int类型，并返回当前数据
        p,ok := interface{}(val).(int)
        item = 0
        res = false
        if ok {
           item = p
           res = true
      }
        return item,res
   }

   nodef := func(val interface{})(n Node,res bool){
      //断言判断是否是Node类型，并返回当前数据
      p,ok := interface{}(val).(Node)
      n = Node{}
      res = false
      if ok {
         n = p
         res = true
      }
      return n,res
   }

   getPop := func(queue *ItemQueue) {
      if !queue.IsEmpty(){
         node := *queue.Pop()
         item,res := intf(node)
         if res {
            fmt.Println(item)
         }
         n,res := nodef(node)
         if res {
            fmt.Println(n.data)
         }
      }

   }

   queue.Push(1)
   queue.Push(2)
   queue.Push(Node{1,"Hello World"})
   queue.Push(Node{2,"GoLang is Good"})
   getPop(&queue)
   getPop(&queue)
   getPop(&queue)
   getPop(&queue)
   getPop(&queue)
   getPop(&queue)
   getPop(&queue)

}