哈夫曼树--链式结构(建立huffman树、编码、解码)

引子： 用链式结构来建立哈夫曼树。总体思路是： 将每一棵树（这是每一棵树只有一个节点，头节点）放在一个优先队列中（下面的是链表实现的优先队列），频率（rate）小的在队列头，取出队列头两个，频率相加之后组合成一个有三个节点的树，重新放入优先队列中。重复上面的过程，直到最后只剩下一个，则这最后一个便是哈夫曼树。编码：从叶子节点开始往上。解码：从根节点开始往下。

package tree;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.Stack;

/**
 * 哈夫曼编码解码
 * @author LiangYH
 *
 */
public class HuffmanTest {

	public static void main(String[] args) {
		HuffmanTest tree1 = new HuffmanTest();
		tree1.setRoot("A", 9);
		
		HuffmanTest tree2 = new HuffmanTest();
		tree2.setRoot("B", 5);
		
		HuffmanTest tree3 = new HuffmanTest();
		tree3.setRoot("C", 8);
		HuffmanTest tree4 = new HuffmanTest();
		tree4.setRoot("E", 19);
		HuffmanTest tree7 = new HuffmanTest();
		tree7.setRoot("F", 11);
		
		
		MyLink link = new MyLink();
		link.add(tree1);
		link.add(tree2);
		link.add(tree3);
		link.add(tree7);
		link.add(tree4);
		link.printLink();
		
		HuffmanTest t1 = null;
		HuffmanTest t2 = null;
		while(link.size() > 1){
			t1 = link.delete();
			t2 = link.delete();
			t2.growTree(t1);
			link.add(t2);
		}
		
		t2.printTree();
		
		Map<String,List<String>> map = t2.getCodeTable();
		
		t2.printCodeTable(map);
		
		List<String> list = t2.encode("AEBCF");
		
		List<String> li2 = t2.decode(list);
		
		System.out.println();
		System.out.print("解码： ");
		for(String s: li2){
			System.out.print(s);
		}
	}
	
	private List<Node> leaves = null;
	private Map<String, List<String>> codeMap= null;
	
	private Node root = null;
	
	
	public HuffmanTest(){
		leaves = new ArrayList<Node>();
		codeMap = new HashMap<String, List<String>>();
	}
	
	public Map<String,List<String>> getCodeMap(){
		return this.codeMap;
	}
	
	public List<Node> getLeaves(){
		getLeaves(root);
		return this.leaves;
	}
	
	public void setRoot(String item, int rate){
		this.root = new Node(item, rate);
	}
	
	public Node getRoot(){
		return this.root;
	}
	
	public int getRateOfRoot(){
		return this.root.rate;
	}
	
	public void growTree(HuffmanTest newTree){
		Node newNode = new Node();
		//设置子节点
		newNode.leftChild = this.root;
		newNode.rightChild = newTree.getRoot();
		//设置父节点
		this.root.parent = newNode;
		newTree.getRoot().parent = newNode;
		//设置父节点的权重
		newNode.setRate(this.root.rate+newTree.getRateOfRoot());
		//重置根节点
		this.root = newNode;
	}
	
	public void InOrderTraverse(HuffmanTest tree){
		traverse(tree.root);
		
	}
	
	private void traverse(Node node){
		if(node != null){
			System.out.print(node.item+"/"+node.rate+"; ");
			traverse(node.leftChild);
			traverse(node.rightChild);
		}
	}
	
	//获取叶子节点
	private void getLeaves(Node node){
		if(node != null){
			if(node.item != null){
				leaves.add(node);
			}
			getLeaves(node.leftChild);
			
			getLeaves(node.rightChild);
		}
	}

	public Map<String,List<String>> getCodeTable(){
		//获取叶子节点
		getLeaves(root);
		int len = leaves.size();
		for(int i = 0; i < len; i++){
			Node tempNode = leaves.get(i);
			List<String> tempList = new ArrayList<String>();
			
			codeMap.put(tempNode.item, tempList);
			
			while(tempNode.parent != null){
				if(tempNode == tempNode.parent.leftChild){
					tempList.add("0");
				}else if(tempNode == tempNode.parent.rightChild){
					tempList.add("1");
				}
				tempNode = tempNode.parent;
			}
		}
		
		return this.codeMap;
	}
	
	public List<String> encode(String target){
		System.out.println();
		System.out.print(target+" 的编码: ");
		
		List<String> li = new ArrayList<String>();
		
		int len = target.length();
		for(int i = 0; i < len; i++){
			String temp = String.valueOf(target.charAt(i));
			List<String> list = codeMap.get(temp);
			for(int k = list.size()-1; k >= 0; k--){
				System.out.print(list.get(k));
				li.add(list.get(k));
			}
		}
		return li;
	}
	
	/**
	 * 解码
	 * @param codeList 二进制编码
	 * @return 解码结果
	 */
	public List<String> decode(List<String> codeList){
		
		List<String> list = new ArrayList<String>();
		
		Node tempNode = null;
		tempNode = root;
		for(String s: codeList){
			if("0".equals(s)){
				tempNode = tempNode.leftChild;
				if(tempNode.item != null){
					list.add(tempNode.item);
					tempNode = root;
					continue;
				}
			}else if("1".equals(s)){
				tempNode = tempNode.rightChild;
				if(tempNode.item != null){
					list.add(tempNode.item);
					tempNode = root;
					continue;
				}
			}
		}
		return list;
	}
	
	public void printTree(){
		InOrderTraverse(this);
	}
	
	public void printCodeTable(Map<String,List<String>> codeTable){
		Set<Entry<String,List<String>>> set = codeTable.entrySet();
		Iterator<Entry<String,List<String>>> iter = set.iterator();
		System.out.println();
		while(iter.hasNext()){
			Entry<String,List<String>> entry = iter.next();
			System.out.print(entry.getKey()+": ");
			
			List<String> li = entry.getValue();
			for(int i = li.size()-1; i >= 0; i--){
				System.out.print(li.get(i));
				
			}
			System.out.print("; ");
		}
	}
	
	class Node{
		Node leftChild = null;
		Node rightChild = null;
		Node parent = null;
		//字母
		String item = null;
		//字母出现的频率
		int rate = 0;
		
		public Node(){
			
		}
		public Node(String item, int rate){
			this.item = item;
			this.rate = rate;
		}
		
		public void setItem(String item){
			this.item = item;
		}
		
		public void setRate(int rate){
			this.rate = rate;
		}
		
		public void printNode(){
			System.out.println(item+"\\"+rate+"; ");
		}
	}
}

/**
 * 优先链表
 * @author LiangYH
 *
 */
class MyLink{
	
	private LinkNode first = null;
	private int size = 0;
	
	
	public MyLink(){
		
	}
	
	/**
	 * 增加节点，并按照相关顺序从小到大排列
	 * @param tree
	 */
	public void add(HuffmanTest tree){
		LinkNode newNode = new LinkNode(tree);
		
		
		if(first == null){
			first = newNode;
			size++;
		}else{
			boolean isNextNull = false;
			LinkNode previous = first;
			LinkNode temp = first;
			while(tree.getRateOfRoot() > temp.tree.getRateOfRoot()){
				if(temp.next == null){
					isNextNull = true;
					break;
				}
				previous = temp;
				temp = temp.next;
			}
			
			//temp所指的是最后一个
			if(isNextNull){
				temp.next = newNode;
				size++;
				return;
			}
			//如果temp指向的是第一个
			if(temp == first){
				newNode.next = first;
				first = newNode;
				size++;
			}else{
				newNode.next = temp;
				previous.next = newNode;
				size++;
			}
			
		}
	}
	
	/**
	 * 删除最左边的一个元素
	 * @return
	 */
	public HuffmanTest delete(){
		if(isEmpty())
			return null;
		
		LinkNode temp = first;
		first = first.next;
		
		size--;
		return temp.tree;
	}
	
	public boolean isEmpty(){
		return first == null;
	}
	
	public int size(){
		return this.size;
	}
	
	public void printLink(){
		LinkNode temp = first;
		while(temp.next != null){
			System.out.print(temp.tree.getRoot().item+"\\"+temp.tree.getRateOfRoot()+"; ");
			temp = temp.next;
		}
		System.out.println(temp.tree.getRoot().item+"\\"+temp.tree.getRateOfRoot());
	}
	
	/**
	 * 内部类
	 * @author LiangYH
	 *
	 */
	class LinkNode{
		LinkNode next = null;
		HuffmanTest tree;
		
		public LinkNode(HuffmanTest tree){
			this.tree = tree;
		}
	}
	
}