完成stack的接口标准

stack/listarraystack/lastack.go

@@ -0,0 +1,173 @@
+package lastack
+
+import (
+	"github.com/474420502/focus/stack"
+	"github.com/davecgh/go-spew/spew"
+)
+
+type Node struct {
+	elements []interface{}
+	cur      int
+	down     *Node
+}
+
+type Stack struct {
+	top   *Node
+	cache *Node
+	size  uint
+}
+
+func assertImplementation() {
+	var _ stack.IStack = (*Stack)(nil)
+}
+
+func (as *Stack) grow() bool {
+	if as.top.cur+1 == cap(as.top.elements) {
+
+		var grownode *Node
+		if as.cache != nil {
+			grownode = as.cache
+			grownode.cur = -1
+			as.cache = nil
+		} else {
+			var growsize uint
+			if as.size <= 256 {
+				growsize = as.size << 1
+			} else {
+				growsize = 256 + as.size>>2
+			}
+			grownode = &Node{elements: make([]interface{}, growsize, growsize), cur: -1}
+		}
+
+		grownode.down = as.top
+		as.top = grownode
+		return true
+	}
+
+	return false
+}
+
+func (as *Stack) cacheRemove() bool {
+	if as.top.cur == 0 && as.top.down != nil {
+		as.cache = as.top
+		as.top = as.top.down
+		as.cache.down = nil
+		return true
+	}
+
+	return false
+}
+
+func New() *Stack {
+	s := &Stack{}
+	s.size = 0
+	s.top = &Node{elements: make([]interface{}, 8, 8), cur: -1}
+	return s
+}
+
+func NewWithCap(cap int) *Stack {
+	s := &Stack{}
+	s.size = 0
+	s.top = &Node{elements: make([]interface{}, cap, cap), cur: -1}
+	return s
+}
+
+func (as *Stack) Clear() {
+	as.size = 0
+
+	as.top.down = nil
+	as.top.cur = -1
+}
+
+func (as *Stack) Empty() bool {
+	return as.size == 0
+}
+
+func (as *Stack) Size() uint {
+	return as.size
+}
+
+// String 左为Top
+func (as *Stack) String() string {
+	content := ""
+	cur := as.top
+	for ; cur != nil; cur = cur.down {
+		for i, _ := range cur.elements {
+			if cur.cur >= i {
+				content += spew.Sprint(cur.elements[cur.cur-i]) + " "
+			}
+		}
+	}
+
+	if len(content) > 0 {
+		content = content[0 : len(content)-1]
+	} else {
+		content = ""
+	}
+
+	return content
+}
+
+func (as *Stack) Values() []interface{} {
+	result := make([]interface{}, as.size, as.size)
+
+	cur := as.top
+	n := 0
+	for ; cur != nil; cur = cur.down {
+		for i, _ := range cur.elements {
+			if cur.cur >= i {
+				result[n] = cur.elements[cur.cur-i]
+				n++
+			}
+		}
+	}
+
+	return result
+}
+
+func (as *Stack) Index(idx int) (interface{}, bool) {
+	if idx < 0 {
+		return nil, false
+	}
+
+	cur := as.top
+	for cur != nil && idx-cur.cur > 0 {
+		idx = idx - cur.cur - 1
+		cur = cur.down
+	}
+
+	if cur == nil {
+		return nil, false
+	}
+
+	return cur.elements[cur.cur-idx], true
+}
+
+func (as *Stack) Push(v interface{}) {
+	as.grow()
+	as.top.cur++
+	as.top.elements[as.top.cur] = v
+	as.size++
+}
+
+func (as *Stack) Pop() (interface{}, bool) {
+	if as.size <= 0 {
+		return nil, false
+	}
+
+	as.size--
+	if as.cacheRemove() {
+		return as.cache.elements[as.cache.cur], true
+	}
+
+	epop := as.top.elements[as.top.cur]
+	as.top.cur--
+	return epop, true
+}
+
+func (as *Stack) Peek() (interface{}, bool) {
+	if as.size <= 0 {
+		return nil, false
+	}
+	return as.top.elements[as.top.cur], true
+}

stack/listarraystack/lastack_test.go

@@ -0,0 +1,252 @@
+package lastack
+
+import (
+	"testing"
+
+	"github.com/davecgh/go-spew/spew"
+)
+
+func TestPush(t *testing.T) {
+	var result string
+	s := NewWithCap(10)
+
+	result = spew.Sprint(s.Values())
+	if result != "[]" {
+		t.Error(result)
+	}
+
+	l := []int{10, 7, 3, 4, 5, 15}
+	for _, v := range l {
+		s.Push(v)
+	}
+
+	result = spew.Sprint(s.Values())
+	if result != "[15 5 4 3 7 10]" {
+		t.Error(result)
+	}
+
+	if v, ok := s.Peek(); ok {
+		if v != 15 {
+			t.Error(v)
+		}
+	}
+
+	result = spew.Sprint(s.Values())
+	if result != "[15 5 4 3 7 10]" {
+		t.Error(result)
+	}
+
+	if v, ok := s.Pop(); ok {
+		if v != 15 {
+			t.Error(v)
+		}
+	}
+
+	result = spew.Sprint(s.Values())
+	if result != "[5 4 3 7 10]" {
+		t.Error(result)
+	}
+
+	for s.Size() != 1 {
+		s.Pop()
+	}
+
+	result = spew.Sprint(s.Values())
+	if result != "[10]" {
+		t.Error(result)
+	}
+
+	if v, ok := s.Pop(); ok {
+		if v != 10 {
+			t.Error(v)
+		}
+	}
+
+	result = spew.Sprint(s.Values())
+	if result != "[]" {
+		t.Error(result)
+	}
+
+	for i := 0; i < 100; i++ {
+		s.Push(i)
+	}
+
+	if v, _ := s.Index(50); v != 49 {
+		t.Error(v)
+	}
+
+	for i := 0; i < 50; i++ {
+		s.Pop()
+	}
+
+	if v, _ := s.Peek(); v != 49 {
+		t.Error(s.Peek())
+	}
+}
+
+func TestBase(t *testing.T) {
+	s := New()
+
+	l := []int{10, 7, 3, 4, 5, 15}
+	for _, v := range l {
+		s.Push(v)
+	}
+
+	if _, ok := s.Index(-1); ok {
+		t.Error("not ok")
+	}
+
+	if s.String() != "15 5 4 3 7 10" {
+		t.Error(s.String())
+	}
+
+	if s.Size() != 6 {
+		t.Error("Size error, is", s.Size())
+	}
+
+	s.Clear()
+	if !s.Empty() {
+		t.Error("Size should be Empty, is Clean.")
+	}
+
+}
+
+func TestIndex(t *testing.T) {
+	s := New()
+
+	l := []int{10, 7, 3, 4, 5, 15}
+	for _, v := range l {
+		s.Push(v)
+	}
+
+	if v, isfound := s.Index(0); isfound {
+		if v != 15 {
+			t.Error("15 is not equal to 15")
+		}
+	} else {
+		t.Error("index 0 is not exists")
+	}
+
+	for i, tv := range l {
+		if v, isfound := s.Index(len(l) - 1 - i); isfound {
+			if v != tv {
+				t.Error(v, "is not equal to", tv)
+			}
+		} else {
+			t.Error("index 0 is not exists")
+		}
+	}
+
+	s.Pop()
+
+	l = l[0 : len(l)-1]
+	for i, tv := range l {
+		index := len(l) - 1 - i
+		if v, isfound := s.Index(index); isfound {
+			if v != tv {
+				t.Error(v, "is not equal to", tv)
+			}
+		} else {
+			t.Error("index is", index, "is not exists", v, tv)
+		}
+	}
+}
+
+// func BenchmarkIndex(b *testing.B) {
+// 	s := New()
+// 	b.N = 20000000
+
+// 	for i := 0; i < b.N; i++ {
+// 		v := randomdata.Number(0, 65535)
+// 		s.Push(v)
+// 	}
+
+// 	b.ResetTimer()
+// 	b.StartTimer()
+
+// 	for i := 0; i < b.N; i++ {
+// 		s.Index(i)
+// 	}
+// }
+
+// func BenchmarkPush(b *testing.B) {
+// 	s := New()
+// 	b.N = 20000000
+// 	for i := 0; i < b.N; i++ {
+// 		v := randomdata.Number(0, 65535)
+// 		s.Push(v)
+// 	}
+// }
+
+// func BenchmarkGodsPush(b *testing.B) {
+// 	s := arraystack.New()
+// 	b.N = 2000000
+// 	for i := 0; i < b.N; i++ {
+// 		v := randomdata.Number(0, 65535)
+// 		s.Push(v)
+// 	}
+// }
+
+// func BenchmarkPop(b *testing.B) {
+// 	s := New()
+// 	b.N = 2000000
+
+// 	for i := 0; i < b.N; i++ {
+// 		v := randomdata.Number(0, 65535)
+// 		s.Push(v)
+// 	}
+
+// 	b.ResetTimer()
+// 	b.StartTimer()
+
+// 	for i := 0; i < b.N; i++ {
+// 		s.Pop()
+// 	}
+// }
+
+// func BenchmarkGodsPop(b *testing.B) {
+// 	s := arraystack.New()
+// 	b.N = 2000000
+
+// 	for i := 0; i < b.N; i++ {
+// 		v := randomdata.Number(0, 65535)
+// 		s.Push(v)
+// 	}
+
+// 	b.ResetTimer()
+// 	b.StartTimer()
+
+// 	for i := 0; i < b.N; i++ {
+// 		s.Pop()
+// 	}
+// }
+
+// func BenchmarkValues(b *testing.B) {
+// 	s := New()
+// 	for i := 0; i < b.N; i++ {
+// 		v := randomdata.Number(0, 65535)
+// 		s.Push(v)
+// 	}
+
+// 	b.ResetTimer()
+// 	b.StartTimer()
+
+// 	for i := 0; i < b.N; i++ {
+// 		s.Values()
+// 	}
+// }
+
+// func BenchmarkGodsValues(b *testing.B) {
+// 	s := arraystack.New()
+// 	for i := 0; i < b.N; i++ {
+// 		v := randomdata.Number(0, 65535)
+// 		s.Push(v)
+// 	}
+
+// 	b.ResetTimer()
+// 	b.StartTimer()
+
+// 	for i := 0; i < b.N; i++ {
+// 		s.Values()
+// 	}
+// }