Question

这只是我使用ocaml生成的huffman树的一部分。树表示为（char * int list）列表：

[(' ', [0]); ('e', [1; 0]); ('t', [1; 1; 0]); ('a', [1; 1; 1; 0]);
 ('o', [1; 1; 1; 1; 0]); ('n', [1; 1; 1; 1; 1; 0]).....].

(char*int list)是代码和相应的编码比特流。我想知道这是不是正确的树或我理解错了。这样，最长编码的ASC II代码将是255位。原始文件为213.3k，编码后变为227k，而在说明中，我被告知应生成119k周围的文件。我不知道我的问题在哪里，因为我按照说明做了一切。有人可以告诉我这里有什么问题吗？

我最大的问题是：如果我使用霍夫曼编码，只有8个最常用的字符可以节省空间，而其他247个字符会花费额外的空间，这是真的吗？如果不是，为什么？

我写的代码遵循此链接中的说明： http://www.cs.cornell.edu/Courses/cs3110/2012sp/hw/ps3/ps3.html

这是我的编码功能代码：

type huffmantree = Node of huffmantree*(int*int)*huffmantree 
 | Leaf of char*int | Nil
type encoding = char * (int list)

let look_up (chr: char) (encl : encoding list) : int list =
  let rec look_up_rec encl = 
    match encl with
    | [] -> raise (Failure "Not found")
    | (ch,theL)::tl -> if ch = chr then theL
                       else look_up_rec tl
    in
    look_up_rec encl
;;

let get_codes (hm : huffmantree): encoding list = 
  let rec get_codes_rec aTree word=
  match aTree with
  | Nil -> []
  | Node (Leaf(lKey,lFreq),value,Nil) -> [(lKey,[0])]
  | Node (Leaf(lKey,lFreq),value,Leaf(rKey,rFreq)) ->  
    [(lKey,List.append word [0]);(rKey,List.append word [1])]
  | Node (Leaf(lKey,lFreq),value,rNode) -> 
    (lKey,List.append word [0])::(get_codes_rec rNode (List.append     word [1]))
  in
  get_codes_rec hm []
;;

let encode (text : char list) : huffmantree * int list = 
  let sortedT = List.fast_sort (fun ch1 ch2->   
    if (int_of_char ch1)>=(int_of_char) ch2 then 1 else -1) text
  in
  let rec cre_freq_list aList m = 
    match aList with
    | [] -> []
    | hd::[] -> [(hd,m+1)]
    | hd1::hd2::tl -> if hd1=hd2 then cre_freq_list (hd2::tl) (m+1)
                      else (hd1,(m+1))::(cre_freq_list  (hd2::tl) 0)
  in
  let sortedF = List.fast_sort (fun (ch1,fr1) (ch2,fr2) ->
    if fr1>=fr2 then 1 else -1) (cre_freq_list sortedT 0)
  in
  let rec createHuff sortedF= 
    match sortedF with
    | [] -> Nil
    | (ch,va)::[] -> Node (Leaf (ch,va),(256,va),Nil)
    | (ach,aval)::tl -> 
      let rec creH_rec the_tl sib n freq= 
        match the_tl with
        | (bch,bval)::[] -> Node(Leaf (bch,bval),(n,bval+freq),sib)
        | (bch,bval)::btl -> creH_rec btl 
          (Node (Leaf (bch,bval),(n,bval+freq),sib)) (n+1) 
          (freq+bval)
    in creH_rec tl (Leaf(ach,aval)) 256 aval
  in
  let huff = createHuff sortedF
  in
  let rec make_codes text = 
    match text with
    | [] -> []
    | hd::tl -> List.append (look_up hd (get_codes huff)) 
      (make_codes tl)
  in
  (huff,(make_codes text))

Answer 1

查看生成的树，看来您没有实现Huffman的算法。我怀疑你的文本中'e'比任何其他字母更频繁。没有你的代码，我只能猜测，但也许在合并两个最轻的树时，你将结果树插入树列表的末尾进行合并，而不是根据重量将其插入到正确的位置。

在您的代码中createHuff被声明为递归，但没有递归调用。您的函数createHuff从不比较sortedF列表中的值，您认为这不是问题吗？这意味着createHuff将始终生成相同的树（具有不同的标签但具有相同的结构）。

霍夫曼编码的文本文件

1 个答案: