哈夫曼编码

题目：哈夫曼编码字符集{A,B,C,D,E,F},在各电文出现次数为{1,3,4,5,2,5}。要求对其进行哈夫曼树的构造和哈夫曼编码函数的编写，并且进行树的层次遍历。

public class Node implements Comparable<Object>{

   private String data;
   private int weight;
   private Node parent;
   private Node leftChild;
   private Node rightChild;
   private String code;

   //构造方法

   public Node(int weight, String data) {
      super();
      this.data = data;
      this.weight = weight;
   }

   @Override
   /**
    * 重写toString方法获取指定输出格式
    */
   public String toString() {
      return "Node [data=" + data + ", weight=" + weight +"]";
   }


   //重写compareTo，实现对象的比较（此处为权值，权值相同比较data）
   public int compareTo(Object obj){

      Node p = (Node)obj;
      //从大到小顺序
      int temp = p.weight - this.weight;    
      return temp == 0 ? p.data.compareTo(this.data) : temp;

   }

   public boolean isLeftChild() {
      return parent != null && this == parent.leftChild;
   }

   public boolean isRightChild() {
      return parent != null && this == parent.rightChild;
   }

  //get、set方法
    
}

 

/**
 * 哈夫曼树的构造、哈夫曼编码
 * @author Administrator
 *
 */
public class HaffmanTree {

   public static void main(String[] args) {

      ArrayList<Node> nodes = new ArrayList<Node>();
      //哈夫曼编码字符集{A,B,C,D,E,F}
      //各电文出现次数为{1,3,4,5,2,5}
      nodes.add(new Node(1, "A"));
      nodes.add(new Node(3, "B"));
      nodes.add(new Node(4, "C"));
      nodes.add(new Node(5, "D"));
      nodes.add(new Node(2, "E"));
      nodes.add(new Node(5, "F"));

      //Collections.sort(nodes);  //此处排序只能完成一次判断，无法对后面的生成树结点数组进行判断
      //使用克隆对象的原因，后面使用到的哈夫曼编码不是对所有的字符进行显示，
      //所以必须保留原来集合的数据，使用克隆对象保证在创建哈夫曼树后不改变原来集合数据
      //另外，可以避免多余的取数据元素的操作
      ArrayList<Node> rnode = (ArrayList<Node>) nodes.clone();


      System.out.println("创建哈夫曼树：");
      Node root = createTree(rnode);

     

      //哈夫曼编码
      System.out.println("哈夫曼编码：");
      rnode = HaffmanCode(root);

      rnode.retainAll(nodes);  //reatinAll取集合中相同的元素（交集）
      printHaffmanCode(rnode);
   }

   /**
    * 创建哈夫曼树
    */
   private static Node createTree(ArrayList<Node> rnodes) {

      while(rnodes.size() > 1) {

         //每生成一颗二叉树，就对nodes结点数组重新排序
         Collections.sort(rnodes);
         //获取权值最小的两个结点
         Node left = rnodes.get(rnodes.size() - 1);
         Node right = rnodes.get(rnodes.size() - 2);

        

         int weight = left.getWeight() + right.getWeight();

         //生成新节点，新节点的权值为两个子节点的权值之和
         Node parent = new Node(weight, ""+weight);
         parent.setLeftChild(left);
         parent.setRightChild(right);

         left.setParent(parent);
         right.setParent(parent);

         //过程演示：
         System.out.println(left);
         System.out.println(right);
         System.out.println(parent);
         System.out.println();

         rnodes.remove(rnodes.size()-1);
         rnodes.remove(rnodes.size()-1);

         //新节点加到 rnodes
         rnodes.add(parent);      
      }

      return rnodes.get(0);
   }

  

   //哈夫曼编码

   /**
    * 传入一个根节点，根据左0右1原则，对每一个结点进行编码
    * 使用广度优先遍历的方法对每一层进行遍历
    * 执行过程实质为广度优先遍历
    * 步骤如下：
    *    1.首先将根节点放入队列中。
    *    2.当队列为非空时，循环执行步骤3到步骤5，否则执行6；
    *    3.出队列取得一个结点，访问该结点；
    *    4.若该结点的左子树为非空，那么对lcode加"0"赋给左孩子的编码，则将该结点的左子树入队列；
    *    5.若该结点的右子树为非空，那么对rcode加"1"赋给右孩子的编码，则将该结点的右子树入队列；
    *    6.结束。
    *
    * @param root 根结点
    * @return list集合
    */
   private static ArrayList<Node> HaffmanCode(Node root) {

      Queue<Node> queue = new ArrayDeque<Node>();
      ArrayList<Node> list = new ArrayList<Node>();     

      if(root!=null){
         //将根元素加入队列
         queue.offer(root);
      }

      while(!queue.isEmpty()){

         //将该队列的“队尾”元素加入到list中
         //peek() 检索但不删除此队列的头，如果此队列为空，则返回 null
         //poll() 检索并删除此队列的头，如果此队列为空，则返回 null 

         list.add(queue.peek());
         Node p = queue.poll();
         String lcode = p.getCode();
         String rcode = p.getCode();

         //如果左子节点不为null，将它加入到队列
         if(p.getLeftChild() != null){
            lcode = lcode+"0";
            (p.getLeftChild()).setCode(lcode);
            queue.offer(p.getLeftChild());
         }

         //如果右子节点不为null，将它加入到队列
         if(p.getRightChild() != null){
            rcode = rcode+"1";
            p.getRightChild().setCode(rcode);
            queue.offer(p.getRightChild());
         }

      }

      return list;
   }

   private static void printHaffmanCode(ArrayList<Node> node){
      Collections.sort(node); 

      //由于构造哈夫曼树时重写的compreTo方法按照权值排序,所以结果为权值排序由大到小
      Iterator<Node> it = node.iterator();

      while(it.hasNext()) {

         Node temp = it.next();
         String data = temp.getData();
         String code = temp.getCode();
         System.out.printf("%-5s%-6s\n",data,code);
      }
   }   

}

 

运行结果：

创建哈夫曼树：

Node [data=A, weight=1]

Node [data=E, weight=2]

Node [data=3, weight=3]

 

Node [data=3, weight=3]

Node [data=B, weight=3]

Node [data=6, weight=6]

 

Node [data=C, weight=4]

Node [data=D, weight=5]

Node [data=9, weight=9]

 

Node [data=F, weight=5]

Node [data=6, weight=6]

Node [data=11, weight=11]

 

Node [data=9, weight=9]

Node [data=11, weight=11]

Node [data=20, weight=20]

 

哈夫曼编码：

F    10   

D    01   

C    00   

B    111  

E    1101 

A    1100