Use Huffman tree to encode and decode

encode and decode with huffman tree, using BitMap, HashTable, etc.

Author: hutusi

src/bitmap.c

@@ -42,7 +42,7 @@ BitMap *bitmap_new(unsigned int num_bits)
 {
     BitMap *bitmap = (BitMap *)malloc(sizeof(BitMap));
     bitmap->num_bits = num_bits;
-    if (num_bits % BITS_PER_WORD == 0) {
+    if (num_bits != 0 && (num_bits % BITS_PER_WORD) == 0) {
         bitmap->num_words = num_bits / BITS_PER_WORD;
     } else {
         bitmap->num_words = num_bits / BITS_PER_WORD + 1;
@@ -51,6 +51,16 @@ BitMap *bitmap_new(unsigned int num_bits)
     return bitmap;
 }
 
+BitMap *bitmap_clone(const BitMap *bitmap)
+{
+    BitMap *clone = (BitMap *)malloc(sizeof(BitMap));
+    clone->num_bits = bitmap->num_bits;
+    clone->num_words = bitmap->num_words;
+    clone->words = (word_t *)malloc(sizeof(word_t) * bitmap->num_words);
+    memcpy(clone->words, bitmap->words, sizeof(word_t) * bitmap->num_words);
+    return clone;
+}
+
 void bitmap_free(BitMap *bitmap)
 {
     free(bitmap->words);
@@ -112,3 +122,36 @@ unsigned int bitmap_count(const BitMap *bitmap)
     }
     return count;
 }
+
+BitMap *bitmap_append(BitMap *bitmap, int flag)
+{
+    if (bitmap->num_words * BITS_PER_WORD <= bitmap->num_bits) {
+        ++(bitmap->num_words);
+        bitmap->words =
+            (word_t *)realloc(bitmap, sizeof(word_t) * bitmap->num_words);
+    }
+
+    if (flag) {
+        set_bit(bitmap->words, bitmap->num_bits);
+    } else {
+        clear_bit(bitmap->words, bitmap->num_bits);
+    }
+
+    ++(bitmap->num_bits);
+    return bitmap;
+}
+
+// BitMap *bitmap_concat(BitMap *bitmap, const BitMap *other) {
+//     return bitmap;
+// }
+
+char *bitmap_to_string(BitMap *bitmap)
+{
+    char *string = (char *)malloc(sizeof(char) * (bitmap->num_bits + 1));
+    for (unsigned int i = 0; i < bitmap->num_bits; ++i) {
+        int flag = bitmap_get(bitmap, i);
+        string[i] = '0' + flag;
+    }
+    string[bitmap->num_bits] = '\0';
+    return string;
+}

src/bitmap.h

@@ -91,6 +91,14 @@ typedef struct _BitMap {
  */
 BitMap *bitmap_new(unsigned int num_bits);
 
+/**
+ * @brief Clone a BitMap and return it's clone.
+ * 
+ * @param bitmap    The BitMap.
+ * @return BitMap*  The clone.
+ */
+BitMap *bitmap_clone(const BitMap *bitmap);
+
 /**
  * @brief Delete a BitMap and free back memory.
  *
@@ -169,4 +177,30 @@ void bitmap_xor(BitMap *bitmap, const BitMap *other);
  */
 unsigned int bitmap_count(const BitMap *bitmap);
 
+/**
+ * @brief Append a bit (0 or 1) to a BitMap.
+ * 
+ * @param bitmap    The BitMap.
+ * @param flag      Bit flag 0 or 1 append to the BitMap.
+ * @return BitMap*  The BitMap.
+ */
+BitMap *bitmap_append(BitMap *bitmap, int flag);
+
+/**
+ * @brief Concat another BitMap to a BitMap.
+ * 
+ * @param bitmap    The BitMap.
+ * @param other     The BitMap.
+ * @return BitMap*  The concated BitMap.
+ */
+BitMap *bitmap_concat(BitMap *bitmap, const BitMap *other);
+
+/**
+ * @brief Convert a BitMap to a printable string.
+ * 
+ * @param bitmap    The BitMap.
+ * @return char*    The char string. (Need free by caller.)
+ */
+char *bitmap_to_string(BitMap *bitmap);
+
 #endif /* #ifndef RETHINK_C_BITMAP_H */

src/dup.c

@@ -9,12 +9,19 @@
  */
 
 #include "dup.h"
-#include "def.h"
 #include <stdlib.h>
+#include "def.h"
 
 int *intdup(int value)
 {
     int *dup = (int *)malloc(sizeof(int));
     *dup = value;
     return dup;
 }
+
+char *char_dup(char value)
+{
+    char *dup = (char *)malloc(sizeof(char));
+    *dup = value;
+    return dup;
+}

src/dup.h

@@ -24,4 +24,12 @@
  */
 int *intdup(int value);
 
+/**
+ * @brief Duplicate a char and return it's pointer.
+ * 
+ * @param value     The original value.
+ * @return int*     The pointer.
+ */
+char *char_dup(char value);
+
 #endif /* #ifndef RETHINK_C_DUP_H */

src/hash.c

@@ -14,7 +14,7 @@
 
 unsigned int hash_char(void *pointer)
 {
-    return *(unsigned int *)pointer;
+    return *(unsigned char *)pointer;
 }
 
 unsigned int hash_int(void *pointer)

src/huffman.c

@@ -9,12 +9,14 @@
  */
 
 #include "huffman.h"
+#include "compare.h"
 #include "def.h"
+#include "hash.h"
+#include "hash_table.h"
 
-static inline int huffman_node_compare(HuffmanNode *node1,
-                                        HuffmanNode *node2)
+static inline int huffman_node_compare(HuffmanNode *node1, HuffmanNode *node2)
 {
-    if (node1->weight > node2->weight) {
+    if (node1->weight < node2->weight) {
         return -1;
     } else if (node1->weight > node2->weight) {
         return 1;
@@ -57,7 +59,7 @@ static inline HuffmanNode *huffman_heap_pop(Heap *heap)
 HuffmanTree *huffman_tree_new(Heap *heap)
 {
     HuffmanTree *tree = (HuffmanTree *)malloc(sizeof(HuffmanTree));
-    
+
     HuffmanNode *node1 = NULL;
     HuffmanNode *node2 = NULL;
 
@@ -71,6 +73,7 @@ HuffmanTree *huffman_tree_new(Heap *heap)
 
         unsigned int weight = node1->weight + node2->weight;
         HuffmanNode *node = huffman_node_new('\0', weight);
+        heap_insert(heap, node);
 
         if (node1->weight < node2->weight) {
             node->left = node1;
@@ -102,3 +105,87 @@ void huffman_tree_free(HuffmanTree *tree)
     huffman_tree_postorder_free(tree->root);
     free(tree);
 }
+
+static inline huffman_node_is_leave(HuffmanNode *node)
+{
+    return node->left == NULL && node->right == NULL;
+}
+
+static void huffman_tree_postorder_to_hash_table(HuffmanNode *node,
+                                                 HashTable *hash_table,
+                                                 BitMap *bitmap)
+{
+    if (node == NULL) {
+        return;
+    }
+
+    if (node->left != NULL) {
+        BitMap *left_bitmap = bitmap_clone(bitmap);
+        bitmap_append(left_bitmap, 0);
+        huffman_tree_postorder_to_hash_table(
+            node->left, hash_table, left_bitmap);
+    }
+
+    if (node->right != NULL) {
+        BitMap *right_bitmap = bitmap_clone(bitmap);
+        bitmap_append(right_bitmap, 1);
+        huffman_tree_postorder_to_hash_table(
+            node->right, hash_table, right_bitmap);
+    }
+
+    if (huffman_node_is_leave(node)) {
+        // todo: char_dup is not valid here.!!!
+        char *ch = (char *)malloc(sizeof(char));
+        *ch = node->value;
+        hash_table_insert(hash_table, ch, bitmap);
+    } else {
+        bitmap_free(bitmap);
+    }
+}
+
+static HashTable *huffman_tree_to_hash_table(HuffmanTree *tree)
+{
+    /** key: char, value: bitmap */
+    HashTable *hash_table =
+        hash_table_new(hash_char, char_equal, free, bitmap_free);
+    HuffmanNode *node = tree->root;
+    BitMap *bitmap = bitmap_new(0);
+    huffman_tree_postorder_to_hash_table(tree->root, hash_table, bitmap);
+    return hash_table;
+}
+
+BitMap *huffman_encode(HuffmanTree *tree, Text *text)
+{
+    /** key: char, value: bitmap */
+    HashTable *hash_table = huffman_tree_to_hash_table(tree);
+    BitMap *bitmap = bitmap_new(0);
+
+    for (unsigned int i = 0; i < text_length(text); ++i) {
+        char ch = text_char_at(text, i);
+        BitMap *bits = (BitMap *)hash_table_get(hash_table, &ch);
+        for (unsigned int j = 0; j < bits->num_bits; ++j) {
+            bitmap_append(bitmap, bitmap_get(bits, j));
+        }
+    }
+    hash_table_free(hash_table);
+    return bitmap;
+}
+
+Text *huffman_decode(HuffmanTree *tree, BitMap *code)
+{
+    Text *text = text_new();
+    HuffmanNode *node = tree->root;
+    for (unsigned int i = 0; i < code->num_bits; ++i) {
+        if (bitmap_get(code, i)) {
+            node = node->right;
+        } else {
+            node = node->left;
+        }
+
+        if (huffman_node_is_leave(node)) {
+            text_append(text, node->value);
+            node = tree->root;
+        }
+    }
+    return text;
+}

src/huffman.h

@@ -18,6 +18,8 @@
 #define RETHINK_C_HUFFMAN_H
 
 #include "heap.h"
+#include "bitmap.h"
+#include "text.h"
 
 /**
  * @brief Definition of a @ref HuffmanNode.
@@ -80,4 +82,7 @@ HuffmanTree *huffman_tree_new(Heap *heap);
  */
 void huffman_tree_free(HuffmanTree *tree);
 
+BitMap *huffman_encode(HuffmanTree *tree, Text *text);
+Text *huffman_decode(HuffmanTree *tree, BitMap *code);
+
 #endif /* #ifndef RETHINK_C_HUFFMAN_H */

src/text.c

@@ -15,7 +15,7 @@
 
 /**
  * @brief All ways append '\0' to text, for dapat c string.
- * 
+ *
  */
 
 /**
@@ -30,7 +30,7 @@ struct _Text {
 
 static inline Text *text_new_with_size(unsigned int size)
 {
-    Text *text= (Text *)malloc(sizeof(Text));
+    Text *text = (Text *)malloc(sizeof(Text));
     text->_allocated = size;
     text->length = 0;
     text->data = (char *)malloc(text->_allocated * sizeof(char));
@@ -118,3 +118,16 @@ int text_equal(const Text *text1, const Text *text2)
 {
     return text_compare(text1, text2) == 0;
 }
+
+Text *text_append(Text *text, char ch)
+{
+    if ((text->length + 1) >= text->_allocated) {
+        text->_allocated += 16;
+        text->data = (char *)realloc(text->data, text->_allocated);
+    }
+
+    text->data[text->length] = ch;
+    ++(text->length);
+    text->data[text->length] = '\0';
+    return text;
+}

src/text.h

@@ -110,4 +110,13 @@ int text_compare(const Text *text1, const Text *text2);
  */
 int text_equal(const Text *text1, const Text *text2);
 
+/**
+ * @brief Append a charactor to a Text.
+ * 
+ * @param text      The Text.
+ * @param ch        The charactor.
+ * @return Text*    The appended Text.
+ */
+Text *text_append(Text *text, char ch);
+
 #endif /* #ifndef RETHINK_C_TEXT_H */

test/CMakeLists.txt

@@ -2,6 +2,7 @@ add_library(testcases alloc-testing.c test_helper.c test_arraylist.c test_list.c
                  test_queue.c test_bitmap.c test_matrix.c 
                  test_bstree.c test_avltree.c test_rbtree.c test_heap.c
                  test_bignum.c test_dijkstra.c test_prime.c test_hash_table.c
-                 test_kmp.c test_bm.c test_sunday.c test_trie.c test_ac.c test_text.c)
+                 test_kmp.c test_bm.c test_sunday.c test_trie.c test_ac.c test_text.c
+                 test_huffman.c)
 target_compile_options(testcases PRIVATE ${COMPILE_OPTIONS})
 target_include_directories(testcases PRIVATE ${INCLUDE_DIRECTORIES})