unify bag and stack to linklist

Author: shellfly

algs4/bag.go

@@ -4,29 +4,12 @@ import (
 	"github.com/shellfly/algo/linklist"
 )
 
-// Bag is a generic interface for bag
+// Bag implements a bag data type by linklist
 type Bag struct {
 	*linklist.LinkList
-	n int
 }
 
-// NewBag creates a new Bag object
+// NewBag ...
 func NewBag() *Bag {
-	return &Bag{linklist.NewLinkList(), 0}
-}
-
-// Add a new item to bag
-func (b *Bag) Add(item interface{}) {
-	b.LinkList.Add(item)
-	b.n++
-}
-
-// Size of the bag
-func (b *Bag) Size() int {
-	return b.n
-}
-
-// IsEmpty returns true if bag is empty
-func (b *Bag) IsEmpty() bool {
-	return b.n == 0
+	return &Bag{linklist.NewLinkList()}
 }

algs4/queue.go

@@ -60,3 +60,19 @@ func (q Queue) Slice() (items []interface{}) {
 	}
 	return
 }
+
+// IntSlice returns a slice of int values for iterating
+func (q *Queue) IntSlice() (items []int) {
+	for curr := q.first; curr != nil; curr = curr.Next {
+		items = append(items, curr.Item.(int))
+	}
+	return
+}
+
+// StringSlice returns a slice of int values for iterating
+func (q *Queue) StringSlice() (items []string) {
+	for curr := q.first; curr != nil; curr = curr.Next {
+		items = append(items, curr.Item.(string))
+	}
+	return
+}

algs4/stack.go

@@ -2,47 +2,26 @@ package algs4
 
 import "github.com/shellfly/algo/linklist"
 
-// Stack ...
+// Stack implements a stack by linklist
 type Stack struct {
-	first *linklist.Node
-	n     int
+	*linklist.LinkList
 }
 
 // NewStack ...
 func NewStack() *Stack {
-	return &Stack{}
-}
-
-// IsEmpty ...
-func (s Stack) IsEmpty() bool {
-	return s.first == nil
+	return &Stack{linklist.NewLinkList()}
 }
 
 // Push ...
 func (s *Stack) Push(item interface{}) {
-	s.first = linklist.NewNode(item, s.first)
-	s.n++
+	s.LinkList.Add(item)
 }
 
 // Pop ...
 func (s *Stack) Pop() (item interface{}) {
 	if s.IsEmpty() {
 		panic("Stack Empty")
 	}
-	item = s.first.Item
-	s.first = s.first.Next
-	return
-}
-
-// Size ...
-func (s Stack) Size() int {
-	return s.n
-}
-
-// Slice ...
-func (s Stack) Slice() (items []interface{}) {
-	for !s.IsEmpty() {
-		items = append(items, s.Pop())
-	}
+	item = s.Del()
 	return
 }

cmd/bag/main.go

@@ -43,7 +43,7 @@ func main() {
 	}
 
 	fmt.Println("size of bag = ", bag.Size())
-	for _, item := range bag.Slice() {
+	for _, item := range bag.StringSlice() {
 		fmt.Println(item)
 	}
 }

cmd/stack/main.go

@@ -7,21 +7,7 @@
  *  to be or not to - be - - that - - - is
  *
  *  % go run cmd/stack/main.go < tobe.txt
- *  size of stack = 14
- *  is
- *  -
- *  -
- *  -
- *  that
- *  -
- *  -
- *  be
- *  -
- *  to
- *  not
- *  or
- *  be
- *  to
+ *  to be not that or be (2 left on stack)
  *
  ******************************************************************************/
 
@@ -38,11 +24,11 @@ func main() {
 	words := stdin.ReadAllStrings()
 	stack := algs4.NewStack()
 	for _, word := range words {
-		stack.Push(word)
-	}
-
-	fmt.Println("size of stack = ", stack.Size())
-	for item := stack.Pop(); !stack.IsEmpty(); item = stack.Pop() {
-		fmt.Println(item)
+		if !(word == "-") {
+			stack.Push(word)
+		} else if !stack.IsEmpty() {
+			fmt.Print(stack.Pop(), " ")
+		}
 	}
+	fmt.Println("(", stack.Size(), " left on stack)")
 }

linklist/util.go

@@ -13,25 +13,61 @@ func NewNode(item interface{}, next *Node) *Node {
 
 // LinkList ...
 type LinkList struct {
-	first *Node
+	First *Node
+	n     int // size
 }
 
-// Add adds a new node
-func (l *LinkList) Add(item interface{}) (n *Node) {
-	n = NewNode(item, l.first)
-	l.first = n
+// NewLinkList return a linked list
+func NewLinkList() *LinkList {
+	return &LinkList{nil, 0}
+}
+
+// Add adds a new node to head, points to old head
+func (l *LinkList) Add(item interface{}) (node *Node) {
+	node = NewNode(item, l.First)
+	l.First = node
+	l.n++
+	return
+}
+
+// Del removes head and returns its Item
+func (l *LinkList) Del() (item interface{}) {
+	item = l.First.Item
+	l.First = l.First.Next
+	l.n--
 	return
 }
 
+// Size returns number of nodes in link list
+func (l *LinkList) Size() int {
+	return l.n
+}
+
+// IsEmpty reports if the link list is empty
+func (l *LinkList) IsEmpty() bool {
+	return l.First == nil
+}
+
 // Slice returns a slice of link list for iterating
 func (l *LinkList) Slice() (items []interface{}) {
-	for curr := l.first; curr != nil; curr = curr.Next {
+	for curr := l.First; curr != nil; curr = curr.Next {
 		items = append(items, curr.Item)
 	}
 	return
 }
 
-// NewLinkList return a linked list
-func NewLinkList() *LinkList {
-	return &LinkList{nil}
+// IntSlice returns a slice of int values for iterating
+func (l *LinkList) IntSlice() (items []int) {
+	for curr := l.First; curr != nil; curr = curr.Next {
+		items = append(items, curr.Item.(int))
+	}
+	return
+}
+
+// StringSlice returns a slice of int values for iterating
+func (l *LinkList) StringSlice() (items []string) {
+	for curr := l.First; curr != nil; curr = curr.Next {
+		items = append(items, curr.Item.(string))
+	}
+	return
 }