From 6d7e0dffd5f8aefa5723177d9635c23572a0a727 Mon Sep 17 00:00:00 2001
From: Julian <jb@futureplay.de>
Date: Thu, 27 Sep 2018 02:17:56 +0200
Subject: [PATCH 1/4] add huffman encoding in go

---
 .../huffman_encoding/code/golang/huffman.go   | 127 ++++++++++++++++++
 contents/huffman_encoding/huffman_encoding.md |   2 +
 2 files changed, 129 insertions(+)
 create mode 100644 contents/huffman_encoding/code/golang/huffman.go

diff --git a/contents/huffman_encoding/code/golang/huffman.go b/contents/huffman_encoding/code/golang/huffman.go
new file mode 100644
index 000000000..be0c53716
--- /dev/null
+++ b/contents/huffman_encoding/code/golang/huffman.go
@@ -0,0 +1,127 @@
+package main
+
+import (
+	"fmt"
+	"sort"
+)
+
+type node struct {
+	freq  int
+	char  rune
+	left  *node
+	right *node
+}
+
+type codebook map[rune]string
+
+func buildTree(message string) *node {
+	freqMap := make(map[rune]*node)
+	nodeList := make([]*node, 0)
+
+	for _, char := range message {
+		if _, ok := freqMap[char]; ok {
+			freqMap[char].freq++
+		} else {
+			newNode := new(node)
+			newNode.freq = 1
+			newNode.char = char
+			freqMap[char] = newNode
+			nodeList = append(nodeList, newNode)
+		}
+	}
+
+	for len(nodeList) > 1 {
+		sort.Slice(nodeList, func(i, j int) bool {
+			return nodeList[i].freq < nodeList[j].freq
+		})
+
+		left := nodeList[0]
+		right := nodeList[1]
+		nodeList = nodeList[2:]
+		branch := new(node)
+		nodeList = append(nodeList, branch)
+		branch.left = left
+		branch.right = right
+		branch.freq = left.freq + right.freq
+	}
+
+	return nodeList[0]
+}
+
+func codebookRecurse(node *node, cb *codebook, code []rune) {
+	if node == nil {
+		return
+	}
+
+	if node.left == nil && node.right == nil {
+		(*cb)[node.char] = string(code)
+	}
+
+	// 0x30 == "0" and 0x31 == "1"
+	code = append(code, 0x30)
+	codebookRecurse(node.left, cb, code)
+	code = append(code[:len(code)-1], 0x31)
+	codebookRecurse(node.right, cb, code)
+}
+
+func encode(message string) (string, *node, codebook) {
+	ret := ""
+	root := buildTree(message)
+	cb := generateCodebook(root)
+	for _, char := range message {
+		ret += cb[char]
+	}
+
+	return ret, root, cb
+}
+
+func decode(message string, root *node) string {
+	cur := root
+	ret := ""
+
+	for _, char := range message {
+		if cur == nil {
+			return message
+		}
+
+		switch string(char) {
+		case "0":
+			if cur.left == nil {
+				ret += string(cur.char)
+				cur = root.left
+			} else {
+				cur = cur.left
+			}
+		case "1":
+			if cur.right == nil {
+				ret += string(cur.char)
+				cur = root.right
+			} else {
+				cur = cur.right
+			}
+		}
+	}
+
+	if cur.char != 0 {
+		ret += string(cur.char)
+	}
+
+	return ret
+}
+
+func generateCodebook(root *node) codebook {
+	cb := make(codebook)
+	codeArr := make([]rune, 0)
+	codebookRecurse(root, &cb, codeArr)
+	return cb
+}
+
+func main() {
+	enc, root, cb := encode("bibbity_bobbity")
+	fmt.Println("Codebook:")
+	for r, c := range cb {
+		fmt.Println(string(r), "->", c)
+	}
+	fmt.Println("\nEncoded:", enc)
+	fmt.Println("Decoded:", decode(enc, root))
+}
diff --git a/contents/huffman_encoding/huffman_encoding.md b/contents/huffman_encoding/huffman_encoding.md
index 9ae6290d6..a0e77f36a 100644
--- a/contents/huffman_encoding/huffman_encoding.md
+++ b/contents/huffman_encoding/huffman_encoding.md
@@ -77,6 +77,8 @@ Whether you use a stack or straight-up recursion also depends on the language, b
 [import, lang:"javascript"](code/javascript/huffman.js)
 {% sample lang="java" %}
 [import, lang:"java"](code/java/huffman.java)
+{% sample lang="go" %}
+[import, lang:"golang"](code/golang/huffman.go)
 {% endmethod %}
 
 <script>

From 2d232a5e94b1c07bf014fda458689b01f90f10e1 Mon Sep 17 00:00:00 2001
From: Julian <jb@futureplay.de>
Date: Tue, 9 Oct 2018 18:36:06 +0200
Subject: [PATCH 2/4] change the name golang to go

---
 contents/huffman_encoding/huffman_encoding.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contents/huffman_encoding/huffman_encoding.md b/contents/huffman_encoding/huffman_encoding.md
index a0e77f36a..a8395dab4 100644
--- a/contents/huffman_encoding/huffman_encoding.md
+++ b/contents/huffman_encoding/huffman_encoding.md
@@ -78,7 +78,7 @@ Whether you use a stack or straight-up recursion also depends on the language, b
 {% sample lang="java" %}
 [import, lang:"java"](code/java/huffman.java)
 {% sample lang="go" %}
-[import, lang:"golang"](code/golang/huffman.go)
+[import, lang:"go"](code/golang/huffman.go)
 {% endmethod %}
 
 <script>

From 50d1510d610539e906543392ddfc69cef0daeb45 Mon Sep 17 00:00:00 2001
From: Julian <jb@futureplay.de>
Date: Tue, 9 Oct 2018 19:14:17 +0200
Subject: [PATCH 3/4] change the hex representation to the char

---
 contents/huffman_encoding/code/golang/huffman.go | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/contents/huffman_encoding/code/golang/huffman.go b/contents/huffman_encoding/code/golang/huffman.go
index be0c53716..59e220987 100644
--- a/contents/huffman_encoding/code/golang/huffman.go
+++ b/contents/huffman_encoding/code/golang/huffman.go
@@ -57,10 +57,9 @@ func codebookRecurse(node *node, cb *codebook, code []rune) {
 		(*cb)[node.char] = string(code)
 	}
 
-	// 0x30 == "0" and 0x31 == "1"
-	code = append(code, 0x30)
+	code = append(code, '0')
 	codebookRecurse(node.left, cb, code)
-	code = append(code[:len(code)-1], 0x31)
+	code = append(code[:len(code)-1], '1')
 	codebookRecurse(node.right, cb, code)
 }
 

From cbbc865ee3f561fac13938ce8dbb0f0055345eda Mon Sep 17 00:00:00 2001
From: Julian <jb@futureplay.de>
Date: Wed, 10 Oct 2018 09:56:31 +0200
Subject: [PATCH 4/4] switch the sort with a heap implementation

---
 .../huffman_encoding/code/golang/huffman.go   | 45 +++++++++++++------
 1 file changed, 31 insertions(+), 14 deletions(-)

diff --git a/contents/huffman_encoding/code/golang/huffman.go b/contents/huffman_encoding/code/golang/huffman.go
index 59e220987..d36903b12 100644
--- a/contents/huffman_encoding/code/golang/huffman.go
+++ b/contents/huffman_encoding/code/golang/huffman.go
@@ -1,8 +1,8 @@
 package main
 
 import (
+	"container/heap"
 	"fmt"
-	"sort"
 )
 
 type node struct {
@@ -13,10 +13,32 @@ type node struct {
 }
 
 type codebook map[rune]string
+type nodeHeap []*node
+
+func (n nodeHeap) Len() int           { return len(n) }
+func (n nodeHeap) Less(i, j int) bool { return n[i].freq > n[j].freq }
+func (n nodeHeap) Swap(i, j int)      { n[i], n[j] = n[j], n[i] }
+
+func (n *nodeHeap) Push(x interface{}) {
+	if node, ok := x.(*node); ok {
+		*n = append(*n, node)
+	} else {
+		fmt.Printf("I got a node of Type %T\n", x)
+	}
+}
+
+func (n *nodeHeap) Pop() interface{} {
+	old := *n
+	l := len(old)
+	x := old[l-1]
+	*n = old[0 : l-1]
+	return x
+}
 
 func buildTree(message string) *node {
 	freqMap := make(map[rune]*node)
-	nodeList := make([]*node, 0)
+	h := new(nodeHeap)
+	heap.Init(h) // really needed?
 
 	for _, char := range message {
 		if _, ok := freqMap[char]; ok {
@@ -26,26 +48,21 @@ func buildTree(message string) *node {
 			newNode.freq = 1
 			newNode.char = char
 			freqMap[char] = newNode
-			nodeList = append(nodeList, newNode)
+			heap.Push(h, newNode)
 		}
 	}
 
-	for len(nodeList) > 1 {
-		sort.Slice(nodeList, func(i, j int) bool {
-			return nodeList[i].freq < nodeList[j].freq
-		})
-
-		left := nodeList[0]
-		right := nodeList[1]
-		nodeList = nodeList[2:]
+	for h.Len() > 1 {
+		left, right := h.Pop().(*node), h.Pop().(*node)
 		branch := new(node)
-		nodeList = append(nodeList, branch)
+		branch.freq = right.freq + left.freq
 		branch.left = left
 		branch.right = right
-		branch.freq = left.freq + right.freq
+		heap.Push(h, branch)
 	}
 
-	return nodeList[0]
+	root := heap.Pop(h).(*node)
+	return root
 }
 
 func codebookRecurse(node *node, cb *codebook, code []rune) {