Huffman编码

最新推荐文章于 2023-01-14 14:11:52 发布

孤独的旅行者_0903

最新推荐文章于 2023-01-14 14:11:52 发布

阅读量486

点赞数

分类专栏：算法

算法专栏收录该内容

17 篇文章 0 订阅

订阅专栏

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Huffman {
 private List<Double> nums;
 private List<Double> numsMo;
 private List<Tree> trees;
 private String temp;

 public Huffman() {
  nums = new ArrayList<Double>();
  numsMo = new ArrayList<Double>();
  trees = new ArrayList<Tree>();
  temp="";
 }

 public void addNums() {// 给定一组数
  System.out.println("请输入一组数，中间用空格分隔：");
  Scanner sca = new Scanner(System.in);
  String str = sca.nextLine();
  String[] strs = str.split(" ");
  for (int i = 0; i < strs.length; i++) {
   nums.add(Double.parseDouble(strs[i]));
   numsMo.add(Double.parseDouble(strs[i]));
  }
 }

 public void compareNum(List<Double> nums,List<Tree> trees) {// 递归算法
  double[] min = new double[2];
  if(nums.size()>1){
   min = minTwo(nums);
   Tree t = new Tree(min[0],min[1],min[0]+min[1]);
   nums.remove(Double.valueOf(min[0]));
   nums.remove(Double.valueOf(min[1]));
   nums.add(min[0]+min[1]);
  // ??????
  trees.add(t);
   compareNum(nums,trees);
  }
 }
//???????????
 public void print(double num) {// 递归打印编码
  for(Tree t : trees){
   if(num == t.getRchild()){
    temp = 1+temp;
    print(t.getParents());
    break;
   }else if(num == t.getLchild()){
    temp = 0+temp;
    print(t.getParents());
    break;
   }
  }
 }
 
 public void write(double d){
  temp = "";
  System.out.print(d+" : ");
  print(d);
  System.out.print(temp);
  System.out.println(" 码长："+temp.length());
 }

 public double[] minTwo(List<Double> nums) {// 在一组数中选则最小的两个，按递增排序

返回
  Double temp = 0.0;
  for (int j = 0; j < 2; j++) {
   for (int i = 1; i < nums.size(); i++) {
    if (nums.get(i - 1) < nums.get(i)) {
     temp = nums.get(i);
     nums.set(i, nums.get(i - 1));
     nums.set(i - 1, temp);
    }
   }
  }
  double[] n = {nums.get(nums.size()-1),nums.get(nums.size()-2)};
  return n;
 }
 
 public void start(){
  addNums();
  compareNum(nums,trees);
  while(numsMo.size()>1){
   double[] mins = minTwo(numsMo);
   if(mins[0]!=mins[1]){
   //?????? 
   numsMo.remove(Double.valueOf(mins[0]));
    write(mins[0]);
   }
  }
  if(!numsMo.isEmpty()){
   write(numsMo.get(0));
  }
 }
 
 public static void main(String[] args){
  new Huffman().start();
 }
}

public class Tree {
 double lChild, rChild, parent;
 public Tree (double lChild, double rChild, double parent) {
  this.lChild = lChild;
  this.rChild = rChild;
  this.parent = parent;
 }
 public double getLchild() {
  return lChild;
 }
 public void setLchild(double lChild) {
  this.lChild = lChild;
 }
 public double getRchild() {
  return rChild;
 }
 public void setRchild(double rChild) {
  this.rChild = rChild;
 }
 public double getParents() {
  return parent;
 }
 public void setParents(double root) {
  this.parent = root;
 }

}

ss问题疑惑：

1.ArrayList、List区别及此句：List<Double> nums=new ArrayList<Double>();解释：

List是一个接口，而ArrayList 是一个类。 ArrayList 继承并实现了List。List list = new ArrayList();这句创建了一个ArrayList的对象后把上溯到了List。此时它是一个List对象了，有些ArrayList有但是List没有的属性和方法，它就不能再用了。而ArrayList list=new ArrayList();创建一对象则保留了ArrayList的所有属性。
为什么一般都使用 List list = new ArrayList() ,而不用 ArrayList alist = new ArrayList()呢？
问题就在于List有多个实现类，如 LinkedList或者Vector等等，现在你用的是ArrayList，也许哪一天你需要换成其它的实现类呢？，这时你只要改变这一行就行了：List list = new LinkedList(); 其它使用了list地方的代码根本不需要改动。假设你开始用 ArrayList alist = new ArrayList(), 这下你有的改了，特别是如果你使用了 ArrayList特有的方法和属性。 ,如果没有特别需求的话,最好使用List list = new LinkedList(); ,便于程序代码的重构. 这就是面向接口编程的好处

2. trees.add(t);解释：

private List<Tree> trees;Tree是自定义的一个类，包含

this.lChild = lChild;

  this.rChild = rChild;
  this.parent = parent;

这几个成员变量。

定义：List<T>类表示可通过索引访问的对象的强类型列表，提供用于对列表进行搜索、排序和操作的方法。

作用：
泛型最常见的用途是泛型集合
我们在创建列表类时，列表项的数据类型可能是int,string或其它类型，如果对列表类的处理方法相同，
就没有必要事先指定数据类型，留待列表类实例化时再指定。相当于把数据类型当成参数，这样可以最
大限度地重用代码，保护类型的安全以及提高性能。

list.iterator();:返回Iterator集合对象.

 迭代器（Iterator）模式，又叫做游标（Cursor）模式。GOF给出的定义为：提供一种方法访问一个容器（container）对象中各个元素，而又不需暴露该对象的内部细节。

Iterator it = result.iterator();
while(it.hasNext())
{
out.println("<H2>try "+it.next());
}

List的一般用法
所属命名空间: System.Collections.Generic
public class List<T>:IList<T>,Icollection<T>,IEnumerable<T>,IList,Icollection,Ienumerable
List<T>是ArrayList类的泛型等效类，该类使用大小可按需动态增加的数组实现IList<T>泛型接口

(1)声明 List<T>mlist = new List<T>();
eg: string[] Arr = {"a","b","c"};
List<string> mlist = new List<string>(Arr);

(2)添加一个元素 List.Add(T item)　
eg: mlist.Add("d");

(3)添加集合元素
eg: string[] Arr2 ={"f","g"."h"};
mlist.AddRange(Arr2);

(4)在index位置添加一个元素 Insert(int index,T item)
eg: mlist.Insert(1,"p");

(5)遍历List中元素

　　foreach(T element in mlist) T的类型与mlist声明时一样
　　　　　{
　　　　　　 Console.WriteLine(element);
}

    eg:
    foreach(string s in mlist)
          {
             Console.WriteLine(s);
           }

(6)删除元素

List.Remove(T item) 删除一个值
eg: mlist.Remove("a");

    List.RemoveAt(int index);删除下标为index的元素
    eg: mlist.RemoveAt(0);

    List.RemoveRange(int index,int count);　下标index开始，删除count个元素
    eg：mlist.RemoveRange(3,2);

(7)判断某个元素是否在该List中

    List.Contains(T item)　返回true或false
    eg:
    if(mlist.Contains"("g"))
       Console.WriteLine("g存在列表中");
    else
       mlist.Add("g");

(8)给List里面元素排序 List.Sort()　默认是元素每一个字母按升序
eg: mlist.Sort();

(9)给List里面元素顺序反转 List.Reverse() 可以与List.Sort()配合使用

(10)List清空 List.Clear()
eg: mlist.Clear();

(11)获得List中元素数目 List.Count()　返回int值
eg: mlist.count();

3. print（）方法解释：

4. if(mins[0]!=mins[1]){ numsMo.remove(Double.valueOf(mins[0]));解释：