class Node:

    def __init__(self, char=None, freq=0):

        self.char = char

        self.freq = freq

        self.left = None

        self.right = None

​

nodes = []

​

def calculate_frequencies(word):

    frequencies = {}

    for char in word:

        if char not in frequencies:

            freq = word.count(char)

            frequencies[char] = freq

            nodes.append(Node(char, freq))

​

def build_huffman_tree():

    while len(nodes) > 1:

        nodes.sort(key=lambda x: x.freq)

        left = nodes.pop(0)

        right = nodes.pop(0)

        merged = Node(freq=left.freq + right.freq)

        merged.left = left

        merged.right = right

        nodes.append(merged)

​

    return nodes[0]

​

def generate_huffman_codes(node, current_code, codes):

    if node is None:

        return

​

    if node.char is not None:

        codes[node.char] = current_code

​

    generate_huffman_codes(node.left, current_code + '0', codes)

    generate_huffman_codes(node.right, current_code + '1', codes)

​

def huffman_encoding(word):

    global nodes

    nodes = []

    calculate_frequencies(word)

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

​

typedef struct Node {

    char charValue;

    int freq;

    struct Node* left;

    struct Node* right;

} Node;

​

Node* nodes[256];

int nodeCount = 0;

​

void calculateFrequencies(const char* word) {

    int frequencies[256] = {0};

    int n = strlen(word);

​

    for (int i = 0; i < n; i++) {

        frequencies[(unsigned char)word[i]]++;

    }

​

    for (int i = 0; i < n; i++) {

        if (frequencies[(unsigned char)word[i]] > 0) {

            nodes[nodeCount] = (Node*)malloc(sizeof(Node));

            nodes[nodeCount]->charValue = word[i];

            nodes[nodeCount]->freq = frequencies[(unsigned char)word[i]];

            nodes[nodeCount]->left = NULL;

            nodes[nodeCount]->right = NULL;

            frequencies[(unsigned char)word[i]] = 0;  // Prevent duplicates

            nodeCount++;

        }

    }

}

​

void insertionSort(Node* arr[], int n) {

    for (int i = 1; i < n; i++) {

        Node* key = arr[i];

        int j = i - 1;

​

        while (j >= 0 && arr[j]->freq > key->freq) {

            arr[j + 1] = arr[j];

            j = j - 1;

        }

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

​

class Node {

    char charValue;

    int freq;

    Node left;

    Node right;

​

    Node(char charValue, int freq) {

        this.charValue = charValue;

        this.freq = freq;

        this.left = null;

        this.right = null;

    }

​

    Node(int freq) {

        this.charValue = '\0';

        this.freq = freq;

        this.left = null;

        this.right = null;

    }

}

​

public class Main {

    static List<Node> nodes = new ArrayList<>();

​

    public static void calculateFrequencies(String word) {

        Map<Character, Integer> frequencies = new HashMap<>();

        for (char charValue : word.toCharArray()) {

            if (!frequencies.containsKey(charValue)) {

                // Count the frequency of the character

                int freq = 0;

                for (char ch : word.toCharArray()) {

                    if (ch == charValue) {

                        freq++;

                    }

                }

                frequencies.put(charValue, freq);

                nodes.add(new Node(charValue, freq));

            }

        }

    }