Refactored Leftist heap

Author: Theo

README.md

@@ -29,7 +29,7 @@ $ go get -u github.com/theodesp/go-heaps
 **Heaps**
 
 * [Pairing Heap](https://en.wikipedia.org/wiki/Pairing_heap): A pairing heap is a type of heap data structure with relatively simple implementation and excellent practical amortized performance.
-* [Leftlist Heap](https://www.geeksforgeeks.org/leftist-tree-leftist-heap/): a variant of a binary heap. Every node has an s-value which is the distance to the nearest leaf. In contrast to a binary heap, a leftist tree attempts to be very unbalanced.
+* [Leftist Heap](https://www.geeksforgeeks.org/leftist-tree-leftist-heap/): a variant of a binary heap. Every node has an s-value which is the distance to the nearest leaf. In contrast to a binary heap, a leftist tree attempts to be very unbalanced.
 * [Skew Heap](https://en.wikipedia.org/wiki/Skew_heap): A skew heap (or self-adjusting heap) is a heap data structure implemented as a binary tree. Skew heaps are advantageous because of their ability to merge more quickly than binary heaps.
 * [Fibonacci Heap](https://en.wikipedia.org/wiki/Fibonacci_heap): a Fibonacci heap is a data structure for priority queue operations, consisting of a collection of heap-ordered trees. It has a better amortized running time than many other priority queue data structures including the binary heap and binomial heap.
 * [Binomial Heap](https://www.geeksforgeeks.org/binomial-heap-2/): A Binomial Heap is a collection of Binomial Trees. A Binomial Heap is a set of Binomial Trees where each Binomial Tree follows Min Heap property. And there can be at most one Binomial Tree of any degree.
@@ -62,7 +62,7 @@ func main()  {
 ```
 
 ## Complexity
-| Operation     | Pairing       | Leftlist      | Skew          | Fibonacci     | Binomial      | Treap         |
+| Operation     | Pairing       | Leftist      | Skew          | Fibonacci     | Binomial      | Treap         |
 | ------------- |:-------------:|:-------------:|:-------------:|:-------------:|:-------------:|:-------------:|
 | FindMin       | Θ(1)          | Θ(1)          | Θ(1)          | Θ(1)			| Θ(log n)      | O(n)          |
 | DeleteMin     | O(log n)      | O(log n)      | O(log n)      | O(log n)	    | Θ(log n)      | O(n)          |

example/leftlist/leftlist.go

@@ -7,7 +7,7 @@ import (
 )
 
 func main() {
-	heap := leftlist.New()
+	heap := leftist.New()
 	heap.Insert(Int(4))
 	heap.Insert(Int(19))
 	heap.Insert(Int(8))

leftlist/leftist_heap.go renamed to leftist/leftist_heap.go

@@ -1,19 +1,19 @@
-package leftlist
+package leftist
 
 import (
 	heap "github.com/theodesp/go-heaps"
 )
 
 // Node is a leaf in the heap.
 type Node struct {
-	Item        heap.Item
-	Left, Right *Node
+	item        heap.Item
+	left, right *Node
 	s           int // s-value (or rank)
 }
 
 // LeftistHeap is a leftist heap implementation.
 type LeftistHeap struct {
-	Root *Node
+	root *Node
 }
 
 func mergeNodes(x, y *Node) *Node {
@@ -25,35 +25,37 @@ func mergeNodes(x, y *Node) *Node {
 		return x
 	}
 	// Compare the roots of two heaps.
-	if x.Item.Compare(y.Item) == 1 {
+	if x.item.Compare(y.item) > 0 {
 		return merge(y, x)
 	} else {
 		return merge(x, y)
 	}
 }
 
 func merge(x, y *Node) *Node {
-	if x.Left == nil {
+	if x.left == nil {
 		// left child doesn't exist, so move right child to the smallest key
-		x.Left = y
-		x.Right = nil
+		// to maintain the leftList invariant
+		x.left = y
+		x.right = nil
 	} else {
-		x.Right = mergeNodes(x.Right, y)
+		x.right = mergeNodes(x.right, y)
 		// left child does exist, so compare s-values
-		if x.Left.s < x.Right.s {
-			x.Left, x.Right = x.Right, x.Left
+		if x.left.s < x.right.s {
+			x.left, x.right = x.right, x.left
 		}
 		// since we know the right child has the lower s-value, we can just
 		// add one to its s-value
-		x.s = x.Right.s + 1
+		x.s = x.right.s + 1
 	}
 
 	return x
 }
 
 // Init initializes or clears the LeftistHeap
 func (h *LeftistHeap) Init() *LeftistHeap {
-	return &LeftistHeap{}
+	h.root = &Node{}
+	return h
 }
 
 // New returns an initialized LeftistHeap.
@@ -62,30 +64,30 @@ func New() *LeftistHeap { return new(LeftistHeap).Init() }
 // Insert adds an item into the heap.
 // The complexity is O(log n) amortized.
 func (h *LeftistHeap) Insert(item heap.Item) heap.Item {
-	h.Root = mergeNodes(&Node{
-		Item: item,
-	}, h.Root)
+	h.root = mergeNodes(&Node{
+		item: item,
+	}, h.root)
 
 	return item
 }
 
 // DeleteMin deletes the minimum value and returns it.
 // The complexity is O(log n) amortized.
 func (h *LeftistHeap) DeleteMin() heap.Item {
-	item := h.Root.Item
+	item := h.root.item
 
-	h.Root = mergeNodes(h.Root.Left, h.Root.Right)
+	h.root = mergeNodes(h.root.left, h.root.right)
 
 	return item
 }
 
 // FindMin finds the minimum value.
 // The complexity is O(1).
 func (h *LeftistHeap) FindMin() heap.Item {
-	return h.Root.Item
+	return h.root.item
 }
 
 // Clear removes all items from the heap.
 func (h *LeftistHeap) Clear() {
-	h.Root = nil
+	h.Init()
 }

leftlist/leftist_heap_test.go renamed to leftist/leftist_heap_test.go

@@ -1,4 +1,4 @@
-package leftlist
+package leftist
 
 import (
 	"sort"
@@ -43,6 +43,25 @@ func TestLeftistHeapString(t *testing.T) {
 	}
 }
 
+func TestLeftistHeap(t *testing.T) {
+	heap := &LeftistHeap{}
+
+	numbers := []int{4, 3, -1, 5, 9}
+
+	for _, number := range numbers {
+		heap.Insert(Int(number))
+	}
+
+	if heap.FindMin() != Int(-1) {
+		t.Fail()
+	}
+
+	heap.Clear()
+	if heap.FindMin() != nil {
+		t.Fail()
+	}
+}
+
 func Int(value int) go_heaps.Integer {
 	return go_heaps.Integer(value)
 }