golang实现简单的栈

栈的ADT

数据

栈的数据对象集合为{a1,a2,a3...an},具有相同数据类型，有唯一前驱后续

操作

• InitStack() *Stack //初始化操作，创建一个空栈
• Clear() //清空栈
• IsEmpty() bool //栈是否为空，若栈为空，返回 true，否则 返回 false。
• Peek() interface{} //若栈存在且非空，返回栈顶元素。
• Push(data interface{}) //将数据data压入栈
• Pop() //若栈不为空，出栈
• Length() int //返回栈中元素个数

代码实现

stack.go

package stack

import (
    "sync"
)

type Stack struct {
    data     []interface{}
    length   int
    capacity int
    sync.Mutex
}

// 构建一个空栈
func InitStack() *Stack {
    return &Stack{data: make([]interface{},8),length: 0,capacity: 8}
}

// 压栈操作
func (s *Stack) Push(data interface{}) {
    s.Lock()
    defer s.Unlock()

    if s.length+1 >= s.capacity {
        s.capacity <<= 1
        t := s.data
        s.data = make([]interface{},s.capacity)
        copy(s.data,t)
    }

    s.data[s.length] = data
    s.length++
}

// 出栈操作
func (s *Stack) Pop() interface{} {
    s.Lock()
    defer s.Unlock()

    if s.length <= 0 {
        panic("int stack pop: index out of range")
    }

    t := s.data[s.length-1]
    s.data = s.data[:s.length-1]
    s.length--

    return t
}

// 返回栈顶元素
func (s *Stack) Peek() interface{} {
    s.Lock()
    defer s.Unlock()

    if s.length <= 0 {
        panic("empty stack")
    }

    return s.data[s.length-1]
}

// 返回当前栈元素个数
func (s *Stack) Count() int {
    s.Lock()
    defer s.Unlock()

    t := s.length

    return t
}

// 清空栈
func (s *Stack) Clear() {
    s.Lock()
    defer s.Unlock()

    s.data = make([]interface{},8)
    s.length = 0
    s.capacity = 8
}

// 栈是否为空
func (s *Stack) IsEmpty() bool {
    s.Lock()
    defer s.Unlock()
    b := s.length == 0
    return b
}

stack_test.go

package stack

import (
    "testing"

    gcv "github.com/smartystreets/goconvey/convey"
)

func TestInitStack(t *testing.T) {
    s := InitStack()
    gcv.Convey("栈不应该为空",t,func() {
        gcv.So(s,gcv.ShouldNotBeNil)
    })
}

func TestPush(t *testing.T) {
    s := InitStack()
    for i := 0; i < 100; i++ {
        s.Push(i)
    }
    gcv.Convey("入栈测试",func() {
        gcv.Convey("栈大小应该为100",func() {
            gcv.So(s.length,gcv.ShouldEqual,100)
        })
        gcv.Convey("栈中元素应该为0-99",func() {
            gcv.So(func() bool {
                for i := 0; i < 100; i++ {
                    if s.data[i] != i {
                        return false
                    }
                }
                return true
            }(),true)
        })
    })
}

func TestPop(t *testing.T) {
    gcv.Convey("出栈测试",func() {
        gcv.Convey("栈中元素应该为99-0",func() {
            gcv.So(func() bool {
                s := InitStack()
                for i := 0; i < 100; i++ {
                    s.Push(i)
                }
                for i := 99; i > -1; i-- {
                    t := s.Pop().(int)
                    if t != i {
                        return false
                    }
                }
                return true
            }(),true)
        })
    })
}

func TestPeek(t *testing.T) {
    gcv.Convey("栈顶操作",func() {
        s := InitStack()
        s.Push(1)
        s.Push(2)
        tmp := s.Peek().(int)
        gcv.So(tmp,2)
    })
}