removed heap module. Used manual allocation

Author: itsfuad

compressor/huffman.go

@@ -1,18 +1,14 @@
 package compressor
 
-import (
-	"container/heap"
-)
-
 // Node represents a node in the Huffman tree
 type Node struct {
-	char  rune    // Character stored in the node
-	freq  int     // Frequency of the character
-	left  *Node   // Left child node
-	right *Node   // Right child node
+	char  rune           // Character stored in the node
+	freq  int            // Frequency of the character
+	left  *Node          // Left child node
+	right *Node          // Right child node
 }
 
-// PriorityQueue implements heap.Interface and holds Nodes
+// PriorityQueue implements a priority queue for Nodes
 type PriorityQueue []*Node
 
 // Len returns the number of items in the priority queue
@@ -29,12 +25,12 @@ func (pq PriorityQueue) Swap(i, j int) {
 }
 
 // Push adds an item (Node) to the priority queue
-func (pq *PriorityQueue) Push(x interface{}) {
-	*pq = append(*pq, x.(*Node))
+func (pq *PriorityQueue) Push(x *Node) {
+	*pq = append(*pq, x)
 }
 
 // Pop removes and returns the highest priority item (Node) from the priority queue
-func (pq *PriorityQueue) Pop() interface{} {
+func (pq *PriorityQueue) Pop() *Node {
 	old := *pq
 	n := len(old)
 	item := old[n-1]
@@ -50,27 +46,55 @@ func buildHuffmanTree(freq map[rune]int) *Node {
 		pq[i] = &Node{char: char, freq: f}
 		i++
 	}
-	heap.Init(&pq)
+	buildMinHeap(pq)
 
 	for len(pq) > 1 {
-		left := heap.Pop(&pq).(*Node)
-		right := heap.Pop(&pq).(*Node)
+		left := pq.Pop()
+		right := pq.Pop()
 
 		internal := &Node{
 			char:  '\x00', // internal node character
 			freq:  left.freq + right.freq,
 			left:  left,
 			right: right,
 		}
-		heap.Push(&pq, internal)
+		pq.Push(internal)
 	}
 
 	if len(pq) > 0 {
-		return heap.Pop(&pq).(*Node) // root of Huffman tree
+		return pq.Pop() // root of Huffman tree
 	}
 	return nil
 }
 
+// buildMinHeap builds a min-heap for the priority queue
+func buildMinHeap(pq PriorityQueue) {
+	n := len(pq)
+	for i := n/2 - 1; i >= 0; i-- {
+		heapify(pq, n, i)
+	}
+}
+
+// heapify maintains the heap property of the priority queue
+func heapify(pq PriorityQueue, n, i int) {
+	smallest := i
+	left := 2*i + 1
+	right := 2*i + 2
+
+	if left < n && pq[left].freq < pq[smallest].freq {
+		smallest = left
+	}
+
+	if right < n && pq[right].freq < pq[smallest].freq {
+		smallest = right
+	}
+
+	if smallest != i {
+		pq.Swap(i, smallest)
+		heapify(pq, n, smallest)
+	}
+}
+
 // buildHuffmanCodes builds Huffman codes (bit strings) for each character
 func buildHuffmanCodes(root *Node) map[rune]string {
 	codes := make(map[rune]string)

resources.rc

@@ -3,8 +3,8 @@
 IDI_ICON1 ICON "icon.ico"
 
 1 VERSIONINFO
-FILEVERSION 0,0,4
-PRODUCTVERSION 0,0,4
+FILEVERSION 0,0,5
+PRODUCTVERSION 0,0,5
 FILEOS 0x4
 FILETYPE 0x1
 {
@@ -14,12 +14,12 @@ FILETYPE 0x1
         {
             VALUE "CompanyName", "BrainbirdLab"
             VALUE "FileDescription", "File Compress-Encryption program"
-            VALUE "FileVersion", "0.0.4"
+            VALUE "FileVersion", "0.0.5"
             VALUE "InternalName", "piarch"
             VALUE "LegalCopyright", "BrainbirdLab"
             VALUE "OriginalFilename", "piarch"
             VALUE "ProductName", "piarch"
-            VALUE "ProductVersion", "0.0.4"
+            VALUE "ProductVersion", "0.0.5"
             VALUE "Author", "Fuad Hasan"
         }
     }