add huffman

Author: shellfly

README.md

@@ -14,7 +14,7 @@ Try to keep the interface and variable name consistent with the original book wh
 ## Note
 
 Unlike Java or Python where you can put `main` function in a file directly. In `go` the `main` function has to be in the `main` package and in the **cmd** directory by convention.
-To test each algorithm(data structure), instead of running the file directly, you have to run the file under **cmd** directory. Example: [cmd/bag/main.go](algs4/cmd/bag/main.go)
+To test each algorithm(data structure), instead of running the file directly, you have to run the file under **cmd** directory. Example: [cmd/bag/main.go](cmd/bag/main.go)
 
 ## Index
 
@@ -31,12 +31,12 @@ To test each algorithm(data structure), instead of running the file directly, yo
   * [Quick](algs4/quick.go)
   * [Quick3Way](algs4/quick_3way.go)
   * [MaxPQ](algs4/max_pq.go)
-  * [TopM](algs4/cmd/topm/main.go)
+  * [TopM](cmd/topm/main.go)
   * [IndexMinPQ](algs4/index_min_pq.go)
-  * [Multiway](algs4/cmd/multiway/main.go)
+  * [Multiway](cmd/multiway/main.go)
   * [Heap](algs4/heap.go)
 * 3 SEARCHING
-  * [FrequencyCounter](algs4/cmd/frequency-counter/main.go)
+  * [FrequencyCounter](cmd/frequency-counter/main.go)
   * [SequentialSearchST](algs4/sequential_search.go)
   * [BinarySearchST](algs4/binary_search_st.go)
   * [BST](algs4/bst.go)
@@ -52,7 +52,7 @@ To test each algorithm(data structure), instead of running the file directly, yo
     * [CC](algs4/cc.go)
     * [Cycle](algs4/cycle.go)
     * [SymbolGraph](algs4/symbol_graph.go)
-    * [DegreesOfSeparation](algs4/cmd/degrees-of-separation/main.go)
+    * [DegreesOfSeparation](cmd/degrees-of-separation/main.go)
   * Digraph
     * [Digraph](algs4/digraph.go)
     * [SymbolDigraph](algs4/symbol_digraph.go)
@@ -79,6 +79,8 @@ To test each algorithm(data structure), instead of running the file directly, yo
   * [TST](algs4/tst.go)
   * [KMP](algs4/kmp.go)
   * [NFA](algs4/nfa.go)
+  * [Huffman](algs4/huffman.go)
+  * [LZW](algs4/lzw.go)
 
 
 ## License

algs4/binarystdin.go

@@ -0,0 +1,107 @@
+package algs4
+
+import (
+	"io"
+	"os"
+	"strings"
+)
+
+// BinaryStdin ...
+var BinaryStdin = &binaryStdin{os.Stdin, 0, 0, false, nil}
+
+type binaryStdin struct {
+	br     io.Reader
+	buffer int // one character buffer
+	n      int // number of bits left in buffer
+	isInitialized bool 
+	err    error
+}
+
+func (bs *binaryStdin) fillBuffer() {
+	byte := make([]byte, 1)
+	_, err := bs.br.Read(byte)
+	if err != nil {
+		if err == io.EOF{
+			bs.err = io.EOF
+			bs.n = -1
+		} else {
+			panic(err)
+		}
+	}
+	bs.n = 8
+	
+	bs.buffer = int(byte[0])
+}
+
+// ReadBool reads the next bit of data from standard input and return as a boolean.
+func (bs *binaryStdin) ReadBool() bool {
+	if bs.IsEmpty(){
+		panic("reading from empty input stream")
+	}
+	bs.n--
+	bit := (bs.buffer>>bs.n & 1) == 1
+	if bs.n == 0 {
+		bs.fillBuffer()
+	}
+	return bit
+}
+
+// ReadInt reads the next 32 bits from standard input and return as a 32-bit int.
+func (bs *binaryStdin) ReadInt() int {
+	if bs.IsEmpty(){
+		panic("reading from empty input stream")
+	}
+	x := 0
+	for i := 0; i < 4; i++ {
+		b := bs.ReadByte()
+		x <<= 8
+		x |= int(b)
+	}
+	return x
+}
+
+// ReadByte the next 8 bits from standard input and return as a byte
+func (bs *binaryStdin) ReadByte() byte {
+	if bs.IsEmpty(){
+		panic("reading from empty input stream")
+	}
+	if bs.n == 8 {
+		b := byte(bs.buffer)
+		bs.fillBuffer()
+		return b
+	}
+	x := bs.buffer
+	x <<= (8 - bs.n)
+	oldN := bs.n
+	bs.fillBuffer()
+	bs.n = oldN
+	x |= (bs.buffer >> bs.n)
+	return byte(x)
+}
+
+// ReadString reads the remaining bytes of data from standard input and return as a string.
+func (bs *binaryStdin) ReadString() string {
+	if bs.IsEmpty(){
+		panic("reading from empty input stream")
+	}
+
+	var sb strings.Builder
+	for !bs.IsEmpty() {
+		b := bs.ReadByte()
+		sb.WriteString(string(b))
+	}
+	return sb.String()
+}
+
+func (bs *binaryStdin) initialize(){
+	bs.fillBuffer()
+	bs.isInitialized = true
+}
+
+// IsEmpty ...
+func (bs *binaryStdin) IsEmpty() bool {
+	if !bs.isInitialized {
+		bs.initialize()
+	}
+	return bs.err == io.EOF
+}

algs4/binarystdout.go

@@ -0,0 +1,85 @@
+package algs4
+
+import (
+	"fmt"
+	"io"
+	"os"
+)
+
+// BinaryStdout ...
+var BinaryStdout = binaryStdout{os.Stdout, 0, 0}
+
+type binaryStdout struct {
+	out    io.Writer
+	buffer int // 8-bit buffer of bits to write
+	n      int // number of bits remaining in buffer
+}
+// WriteInt writes the 32-bit int to standard output
+func (bs *binaryStdout)WriteInt(x int)error{
+	bs.WriteByte(byte((x >> 24) & 0xff))
+	bs.WriteByte(byte((x >> 16) & 0xff))
+	bs.WriteByte(byte((x >>  8) & 0xff))
+	bs.WriteByte(byte((x >>  0) & 0xff))
+	return nil
+}
+
+// Close ...
+func (bs *binaryStdout)Close(){
+	bs.clearBuffer()
+}
+
+// Write...
+func (bs *binaryStdout) Write(p []byte) error {
+	return nil
+}
+
+
+// WriteByte writes the 8-bit byte to standard output.
+func (bs *binaryStdout) WriteByte(b byte) error {
+	if !(int(b) >= 0 && int(b) < 256) {
+		panic("invalid byte")
+	}
+	// // optimized if byte-aligned
+	// if bs.n == 0 {
+	// 	_, err := bs.out.Write([]byte{b})
+	// 	if err != nil {
+	// 		fmt.Println("write byte to stdout error: ", err)
+	// 		return err
+	// 	}
+	// }
+	for i := 0; i < 8; i++ {
+		bit := ((int(b) >> (8 - i - 1)) & 1) == 1
+		bs.WriteBit(bit)
+	}
+	return nil
+}
+
+// WriteBit writes the specified bit to standard output.
+func (bs *binaryStdout) WriteBit(bit bool) error {
+	bs.buffer <<= 1
+	if bit {
+		bs.buffer |= 1
+	}
+	bs.n++
+	if bs.n == 8 {
+		return bs.clearBuffer()
+	}
+	return nil
+}
+
+func (bs *binaryStdout) clearBuffer() error {
+	if bs.n == 0 {
+		return nil
+	}
+	if bs.n > 0 {
+		bs.buffer <<= (8 - bs.n)
+	}
+	_, err := bs.out.Write([]byte{byte(bs.buffer)})
+	if err != nil {
+		fmt.Println("write byte to stdout error: ", err)
+		panic("err")
+	}
+	bs.n = 0
+	bs.buffer = 0
+	return nil
+}

huffman.go algs4/huffman.go

@@ -2,7 +2,6 @@ package algs4
 
 import (
 	"fmt"
-	"github.com/shellfly/algo/stdin"
 )
 
 type huffmanNode struct {
@@ -24,7 +23,7 @@ func (hn *huffmanNode) CompareTo(other interface{}) int {
 	return 0
 }
 func (hn *huffmanNode) String() string {
-	return fmt.Sprintf("%s-%s", hn.ch, hn.freq)
+	return fmt.Sprintf("%c-%d-(%v-%v)", hn.ch, hn.freq, hn.left, hn.right)
 }
 
 // Huffman ...
@@ -39,36 +38,35 @@ func NewHuffman() *Huffman {
 
 // Compress ...
 func (h Huffman) Compress() {
-	s := stdin.NewStdIn().ReadString()
+	s := BinaryStdin.ReadString()
 	freq := make([]int, h.R)
 	for i := 0; i < len(s); i++ {
 		freq[s[i]]++
 	}
 	// build huffman trie
-	root := buildTrie(freq)
+	root := h.buildTrie(freq)
 
 	// build code table
 	st := make([]string, h.R)
 	h.buildCode(st, root, "")
-
 	// print trie for decoder
 	h.writeTrie(root)
 
 	// print number of bytes in original uncompressed message
-	fmt.Println(len(s))
+	BinaryStdout.WriteInt(len(s))
 
 	// use Huffman code to encode input
 	for i := 0; i < len(s); i++ {
 		code := st[s[i]]
 		for j := 0; j < len(code); j++ {
 			if string(code[j]) == "0" {
-				fmt.Print(0)
+				BinaryStdout.WriteBit(false)
 			} else if string(code[j]) == "1" {
-				fmt.Print(1)
+				BinaryStdout.WriteBit(true)
 			}
 		}
 	}
-	fmt.Println(s)
+	BinaryStdout.Close()
 }
 
 func (h Huffman) buildTrie(freq []int) *huffmanNode {
@@ -86,3 +84,49 @@ func (h Huffman) buildTrie(freq []int) *huffmanNode {
 	}
 	return pq.DelMin().(*huffmanNode)
 }
+
+func (h Huffman) writeTrie(x *huffmanNode) {
+	if x.isLeaf() {
+		BinaryStdout.WriteBit(true)
+		BinaryStdout.WriteByte(x.ch)
+		return
+	}
+	BinaryStdout.WriteBit(false)
+	h.writeTrie(x.left)
+	h.writeTrie(x.right)
+}
+
+func (h Huffman) buildCode(st []string, x *huffmanNode, s string) {
+	if !x.isLeaf() {
+		h.buildCode(st, x.left, s+"0")
+		h.buildCode(st, x.right, s+"1")
+	} else {
+		st[x.ch] = s
+	}
+}
+
+// Expand ...
+func (h Huffman) Expand() {
+	root := readTrie()
+	length := BinaryStdin.ReadInt()
+	for i := 0; i < length; i++ {
+		x := root
+		for !x.isLeaf() {
+			bit := BinaryStdin.ReadBool()
+			if bit {
+				x = x.right
+			} else {
+				x = x.left
+			}
+		}
+		BinaryStdout.WriteByte(x.ch)
+	}
+}
+
+func readTrie() *huffmanNode {
+	isLeaf := BinaryStdin.ReadBool()
+	if isLeaf {
+		return &huffmanNode{BinaryStdin.ReadByte(), -1, nil, nil}
+	}
+	return &huffmanNode{'0', -1, readTrie(), readTrie()}
+}

algs4/stack.go

@@ -14,7 +14,7 @@ func NewStack() *Stack {
 
 // Push ...
 func (s *Stack) Push(item interface{}) {
-	s.LinkList.Add(item)
+	s.Add(item)
 }
 
 // Pop ...