Merge branch 'dev'

Author: HaoKunT

Readme.md

@@ -7,5 +7,5 @@ it's some data struct using golang
 - [x] Binary tree
 - [x] Stack
 - [x] Queue
-- [ ] Heap
+- [x] Heap
 - [ ] B/B+ tree

binarytree.go

@@ -65,10 +65,27 @@ func (bt *BinaryTree) PreOrderTraverseRecursive(f BinaryTreeHandleFunc, e Binary
 	r.PreOrderTraverseRecursive(f, e)
 }
 
-// func (bt *BinaryTree) PreOrderTraverseStack(f BinaryTreeHandleFunc, e BinaryTreeErrorHandleFunc) {
-// 	// now we do not have stack data struct
-// 	panic("Sorry we do not have stack now")
-// }
+//PreOrderTraverseStack is a stack based pre-order traversal
+func (bt *BinaryTree) PreOrderTraverseStack(f BinaryTreeHandleFunc, e BinaryTreeErrorHandleFunc) {
+	//now we use a stack to do the traversal
+	var s = make([]*BinaryTreeNode, 0)
+	s = append(s, bt.Root)
+	for len(s) > 0 {
+		h := s[len(s)-1]
+		s = s[:len(s)-1]
+		err := f(h)
+		if err != nil {
+			e(err)
+		}
+		if h.Right != nil {
+			s = append(s, h.Right)
+		}
+		if h.Left != nil {
+			s = append(s, h.Left)
+		}
+	}
+
+}
 
 func (bt *BinaryTree) InOrderTraverseRecursive(f BinaryTreeHandleFunc, e BinaryTreeErrorHandleFunc) {
 	tNode := bt.Root

binarytree_test.go

@@ -236,3 +236,25 @@ func TestBinaryTreeDeep(t *testing.T) {
 		t.Errorf("BinaryTree: Deep error: it should be 3 but get %d", tree.Deep())
 	}
 }
+
+//TestBinaryTreePreOrderTraverseStack
+func TestBinaryTreePreOrderTraverseStack(t *testing.T) {
+	tree := NewBinaryTreeFromNode(NewBinaryTreeNode(1))
+	tree.Root.Left = NewBinaryTreeNode(2)
+	tree.Root.Right = NewBinaryTreeNode(3)
+	tree.Root.Left.Left = NewBinaryTreeNode(4)
+	tree.Root.Left.Right = NewBinaryTreeNode(5)
+
+	var buf bytes.Buffer
+
+	tree.PreOrderTraverseStack(func(node *BinaryTreeNode) error {
+		buf.WriteString(node.String())
+		return nil
+	}, func(err error) {
+		t.Error(err)
+	})
+
+	if buf.String() != "12453" {
+		t.Errorf("BinaryTree: TestBinaryTreePreOrderTraverseStack error: buf.String() should be '12453' but is '%s'", buf.String())
+	}
+}

heap.go

@@ -0,0 +1,65 @@
+package datastruct
+
+import "container/heap"
+
+//Len returns the length of the heap
+func (h *Heap) Len() int {
+	return h.length
+}
+
+//Less returns true if the element at index i is less than the element at index j
+func (h *Heap) Less(i, j int) bool {
+	ii, _ := h.Index(h.length - i - 1)
+	ji, _ := h.Index(h.length - j - 1)
+	in := ii.Value.(*HeapNode)
+	jn := ji.Value.(*HeapNode)
+	//use priority to compare and ismax to decide whether it is a max heap or min heap
+	return (in.Priority > jn.Priority) == h.ismax
+}
+
+//Swap swaps the elements at index i and j
+func (h *Heap) Swap(i, j int) {
+	ii, _ := h.Index(h.length - i - 1)
+	ji, _ := h.Index(h.length - j - 1)
+	//we only swap the value, not the whole node
+	ii.Value, ji.Value = ji.Value, ii.Value
+}
+
+//Push pushes the element x onto the heap.
+func (h *Heap) Push(x interface{}) {
+	node := NewListNode(x)
+	h.Insert(node)
+}
+
+//Pop removes the element with the highest priority from the heap and returns it.
+func (h *Heap) Pop() interface{} {
+	if h.length == 0 {
+		return nil
+	}
+	node, _ := h.Index(0)
+	h.DeleteByIndex(0)
+	return node.Value
+}
+
+//NewHeap returns a new Heap
+func NewHeap(ismax bool) *Heap {
+	return &Heap{
+		LinkedList: NewLinkedList(),
+		ismax:      ismax,
+	}
+}
+
+//NewHeapNode returns a new HeapNode
+func NewHeapNode(value interface{}, priority int) *HeapNode {
+	return &HeapNode{
+		Value:    value,
+		Priority: priority,
+	}
+}
+
+//SetIsMax sets the ismax field of the Heap, it will make a max heap become a min heap, when ismax is false, it will be a min heap and when ismax is true, it will be a max heap. We will reinit the heap after setting it.
+func (h *Heap) SetIsMax(ismax bool) {
+	h.ismax = ismax
+	//reinit the heap
+	heap.Init(h)
+}

heap_test.go

@@ -0,0 +1,79 @@
+package datastruct
+
+import (
+	"container/heap"
+	"testing"
+)
+
+//TestNewMaxHeapNode
+func TestNewHeapNode(t *testing.T) {
+	node1 := NewHeapNode(1, 1)
+
+	if node1.Value != 1 || node1.Priority != 1 {
+		t.Errorf("HeapNode: NewHeapNode error, it should be \" node1.Value == 1 && node1.Priority == 1\"")
+	}
+}
+
+//TestNewMaxHeap
+func TestNewMaxHeap(t *testing.T) {
+	heap := NewHeap(true)
+
+	if heap.length != 0 {
+		t.Errorf("Heap: NewMaxHeap error, it should be \" heap.length == 0\"")
+	}
+}
+
+//TestHeap
+func TestHeap(t *testing.T) {
+	h := NewHeap(true)
+	heap.Init(h)
+
+	heap.Push(h, &HeapNode{Value: 3, Priority: 3})
+	heap.Push(h, &HeapNode{Value: 2, Priority: 2})
+	heap.Push(h, &HeapNode{Value: 1, Priority: 1})
+	heap.Push(h, &HeapNode{Value: 4, Priority: 4})
+	heap.Push(h, &HeapNode{Value: 5, Priority: 5})
+	heap.Push(h, &HeapNode{Value: 6, Priority: 6})
+
+	if h.length != 6 {
+		t.Errorf("Heap: MaxHeap error, it should be \" h.length == 6\" but got %d", h.length)
+	}
+
+	v := heap.Pop(h).(*HeapNode).Value
+	if v != 6 {
+		t.Errorf("Heap: MaxHeap error, it should be \"  h.Pop().(*HeapNode).Value == 6\" but got %d", v)
+	}
+
+	h.SetIsMax(false)
+	v = heap.Pop(h).(*HeapNode).Value
+	if v != 1 {
+		t.Errorf("Heap: MinHeap error, it should be \"  h.Pop().(*HeapNode).Value == 1\" but got %d", v)
+	}
+
+}
+
+//TestHeapReversed
+func TestHeapReversed(t *testing.T) {
+	h := NewHeap(true)
+	heap.Init(h)
+
+	heap.Push(h, &HeapNode{Value: 1, Priority: 4})
+	heap.Push(h, &HeapNode{Value: 2, Priority: 3})
+	heap.Push(h, &HeapNode{Value: 3, Priority: 2})
+	heap.Push(h, &HeapNode{Value: 4, Priority: 1})
+
+	if h.length != 4 {
+		t.Errorf("Heap: MaxHeap error, it should be \" h.length == 5\" but got %d", h.length)
+	}
+
+	v := heap.Pop(h).(*HeapNode).Value
+	if v != 1 {
+		t.Errorf("Heap: MaxHeap error, it should be \"  h.Pop().(*HeapNode).Value == 1\" but got %d", v)
+	}
+
+	h.SetIsMax(false)
+	v = heap.Pop(h).(*HeapNode).Value
+	if v != 4 {
+		t.Errorf("Heap: MinHeap error, it should be \"  h.Pop().(*HeapNode).Value == 4\" but got %d", v)
+	}
+}

linkedlist.go

@@ -68,6 +68,18 @@ func (ll *LinkedList) InsertAt(node *ListNode, index int) error {
 	return nil
 }
 
+//Pop will return the first node and delete it from the list
+func (ll *LinkedList) Pop() (*ListNode, error) {
+	if ll.length == 0 {
+		return nil, errors.New("No Node")
+	}
+	tmpNode := ll.Head
+	ll.Head = ll.Head.Next
+	tmpNode.Next = nil
+	ll.length--
+	return tmpNode, nil
+}
+
 func (ll *LinkedList) String() string {
 	buf := bytes.NewBuffer([]byte{})
 	tmpNode := ll.Head

linklist_test.go

@@ -111,6 +111,34 @@ func TestLinkedListIndex(t *testing.T) {
 	}
 }
 
+//TestLinkedListPop
+func TestLinkedListPop(t *testing.T) {
+	var node1 = &ListNode{
+		Next:  nil,
+		Value: 1,
+	}
+	var node2 = &ListNode{
+		Next:  node1,
+		Value: 2,
+	}
+	var node3 = &ListNode{
+		Next:  node2,
+		Value: 3,
+	}
+	ll := NewLinkedList()
+	ll.Insert(node1)
+	ll.Insert(node2)
+	ll.Insert(node3)
+
+	tNode, err := ll.Pop()
+	if err != nil {
+		t.Errorf("LinkedList: Pop error: %s", err)
+	}
+	if tNode != node3 {
+		t.Errorf("LinkedList: Pop error: it should be node3 but get %v", tNode)
+	}
+}
+
 func TestLinkedListDeleteByIndex(t *testing.T) {
 	var node1 = &ListNode{
 		Next:  nil,

type.go

@@ -31,3 +31,15 @@ type Stack struct {
 type Queue struct {
 	*LinkedList
 }
+
+//Heap is a list which implements heap interface, we use ismax to indicate whether the heap is a max heap or min heap
+type Heap struct {
+	*LinkedList
+	ismax bool //true for max heap, false for min heap
+}
+
+//HeapNode is a node in Heap
+type HeapNode struct {
+	Value    interface{}
+	Priority int
+}