Huffman coding can be implemented in Maple similarly to Python.

First, we need a set of character frequencies. It can be created from a string using the following procedure,

Freq:=s->map(x->rhs(x)=lhs(x),
    {StringTools:-CharacterFrequencies(s)});

For example (used in the wikipedia article),

s:= "this is an example of a huffman tree":

Fr:=Freq(s);

  {1 = "l", 1 = "o", 1 = "p", 1 = "r", 1 = "u", 1 = "x", 2 = "h",

        2 = "i", 2 = "m", 2 = "n", 2 = "s", 2 = "t", 3 = "f", 4 = "a",

        4 = "e", 7 = " "}

I've interchanged the equation sides in CharacterFrequencies so that the set entries were sorted (automatically) by their frequencies - similarly to the Python code.

Now, the Huffman tree can be constructed recursively,

HuffmanTree :=s -> if nops(s)<=1 then rhs(s[]) 
    else procname(s[3..-1] union 
        {lhs(s[1])+lhs(s[2])=[rhs(s[1]),rhs(s[2])]}) 
    fi;

In our example, that gives

HT:=HuffmanTree(Fr);

  HT := [[["a", "e"], [["h", "i"], ["m", "n"]]], [

        [["s", "t"], [["l", "o"], ["p", "r"]]],

        [[["u", "x"], "f"], " "]]]

Now, the binary codes associated to letters, can be also constructed recursively,

HuffmanCoding:=proc(s,p:="")
    if s::string then s=p 
    else procname(s[1],cat(p,0)), procname(s[2],cat(p,1)) 
    fi
end;

In our example,

HC:=HuffmanCoding(HT);

  "a" = "000", "e" = "001", "h" = "0100", "i" = "0101", "m" = "0110",

        "n" = "0111", "s" = "1000", "t" = "1001", "l" = "10100",

        "o" = "10101", "p" = "10110", "r" = "10111", "u" = "11000",

        "x" = "11001", "f" = "1101", " " = "111"

Using that, the original string can be written in binary as

C:=table([HC]):
b:=cat(map(x->C[x],StringTools:-Explode(s))[]);

  "100101000101100011101011000111000011111100111001000011010110101\
        0000111110101110111100011101001100011011101011000001111111\
        00110111001001"

length(b);
                                 135

The decoding can be done using following procedure:

HuffmanDecode:=proc(b,T)
    local h, i, j, ans;
    ans:=Array(1..length(b));
    h:=T;
    j:=0;
    for i to length(b) do 
        if b[i]="0" then h:=h[1] else h:=h[2] fi;
        if h::string then j:=j+1; ans[j]:=h; h:=T fi 
    od;
    StringTools:-Implode([seq(i,i=ans[1..j])])
end:

HuffmanDecode(b,HT);

                "this is an example of a huffman tree"

The encoding operations above can be combined to a single procedure,

HuffmanEncode:=proc(s)
    local C, T, HuffmanTree, HuffmanCoding;
    HuffmanTree :=s -> if nops(s)<=1 then rhs(s[]) 
        else procname(s[3..-1] union 
            {lhs(s[1])+lhs(s[2])=[rhs(s[1]),rhs(s[2])]}) 
        fi;
    HuffmanCoding:=proc(s,p:="")
        if s::string then s=p 
        else procname(s[1],cat(p,0)), procname(s[2],cat(p,1)) 
        fi
    end;
    if _nrest=1 then T:=_rest 
    else T:=HuffmanTree(map(x->rhs(x)=lhs(x),
        {StringTools:-CharacterFrequencies(s)}))    
    fi;
    C:=table([HuffmanCoding(T)]);
    cat(map(x->C[x],StringTools:-Explode(s))[]),
        T
end;

It works rather fast for not very long strings,

s:=StringTools:-Random(10000,ascii):
t:=time():
b:=HuffmanEncode(s):
time()-t;

                                0.015

The decoding procedure is slower,

t:=time():
s1:=HuffmanDecode(b):
time()-t;

                                0.124

evalb(s1=s);

                                 true

For larger strings, time seems to be increasing linearly,

s:=StringTools:-Random(100000,ascii):
t:=time():
b:=HuffmanEncode(s):
time()-t;

                                0.124

t:=time():
s1:=HuffmanDecode(b):
time()-t;

                                1.591

evalb(s1=s);

                                 true

Suggestions (in the code form) are welcomed.

Alec