信息论与编码课程设计实验报告

计算机与信息学院

信息论与编码课程设计实验报告

专业班级

信息安全11-1班

学生姓名及学号

课程教学班号

0001 任课教师

实验指导教师

实验地点

逸夫科技楼507

2013~2014学年第一学期

实验一：对任意的符号序列（abbcccdddddeeeeee）进行n元Huffman的编码实现

一、问题描述

Huffman编码是一种常用的压缩编码方法，是Huffman与1952年为压缩文本文件建立的。它的基本原理是按照概率大小的顺序排列信源符号，并设法按逆顺序分配码字字长，使编码的码字为可辨识的。Huffman码是最佳码。

本次课程设计主要是实现对任意的符号序列进行n元Huffman的编码。

二、基本要求

本程序需要达到的要求是：由使用者输入信源符号（如：abbcccdddddeeeeee）、编码的元数（n）。后运行程序，程序输出每个符号的编码以及信源符号串的编码。再将编码结果输入，译码得出原序列。

三、测试数据

1.

输入符号序列为：abbcaddacaeffghgi 元数为：5

四、算法思想

本算法的n元编码过程实现如下：

（1）将q 个信源按概率分布大小依次排列；

（2）计算实际所需的信源符号数【根据公式：q =（n - 1）θ+ n】；

（3）用0，1，2，……，n-1分别代表概率最小的n个信源符号，并将这n个概率最小的信源符号合并成一个新的符号，并将这n个符号标记为true。使得标记为false的符号数为q-n+1 个，构成的新信源S1；

（4）把信源S1的符号仍按概率大小依递排列，并将其最后n 个概率最小的符号合并成一个符号，并分别用0，1，2，……，r-1码符号表示。这样就形成了标记为false的q-2(n-1)个符号组成的信源S2；

（5）依次继续下去，直至信源最后只剩下n个符号为止。将这最后n个信源符号分别用n 进制符号0，1，?，r-1 表示；

（6）最后，通过递归函数从最后一级缩减信源开始，向前返回，就得出各信源符号所对应的码符号序列，即相应的码字。

译码过程如下：

（1）将输入的字符串转换成char类型数组，取出第一个字符，作为起始字符；

（2）将取出的字符与编码后的编码结果进行比对。若一致则输出与编码结果对应的符号，

并将char数组中的下一个字符作为起始字符。否则取char数组的前两个进行比对，如此循环下去。

五、模块划分

1.计算实际需要的符号数

for(int i=0;i

times[i]=0;

for(int i=0;i

for(int j=0;j

if (sign[i]==get_sign[j])times[i]++;

}

//System.out.print(times[i]+" ");

}

for(int i=0;;){

if((real_sum=i*(n-1)+n)

else break;

}

2.建立Huffman结点

class HuffmanNode { //建立Huffman编码结点

public int frequency;

public boolean flag;

public char name;

public String code;

public HuffmanNode next;

HuffmanNode(char name,int frequency,boolean flag){

https://www.360docs.net/doc/3a8606956.html,=name;

this.frequency=frequency;

this.flag=flag;

this.code="";

this.next=null;

}

}

3. 对HUFFMAN结点数组进行排序

if(circle_times==1){

for(int i=0;i

for(int j=i+1;j

if(node_array[i].frequency>node_array[j].frequency){

HuffmanNode x;

x=node_array[i];

node_array[i]=node_array[j];

node_array[j]=x;

}

}

}

}

if(circle_times!=1){

int j=real_sum-1;

for(int i=real_sum-2;i>=0;i--){

if(node_array[i].frequency>node_array[j].frequency){

HuffmanNode x;

x=node_array[i];

node_array[i]=node_array[j];

node_array[j]=x;

j--;

}

}

}

4. 给出每个符号的码符号

for(int i=0;i

if(count2!=n&&node_array[i].flag==false){

String temp=null;

temp=Integer.toString(count2);

//System.out.println(temp);

node_array[i].code=temp;

//System.out.println(node_array[i].name+" "+node_array[i].code);

count2++;

}

}

5. 合并n个符号

node_array[real_sum]=new

HuffmanNode('*',combine,false);//建立新的huffman结点

for(int i=0;i

if(count!=n&&node_array[i].flag==false&&false_num!=n){

combine=combine+node_array[i].frequency;

count++;

node_array[i].flag=true;

node_array[i].next=node_array[real_sum];

//System.out.println(node_array[i].name+" "+node_array[i].next.frequency);

}

}

//System.out.println(combine);

node_array[real_sum].frequency=combine;

real_sum++;

6.输出码符号序列的递归程序

public void encode(HuffmanNode hn){

if(hn.next!=null&&hn.next.code!=null){

if(hn.next.flag!=false){

encode(hn.next);

hn.code=hn.next.code+hn.code;

hn.flag=false;

}

else

hn.code= hn.next.code+ hn.code;

//System.out.println(hn.code);

}

}

7.译码程序

class ButtonListener2 implements ActionListener{

public void actionPerformed(ActionEvent e){

String s = e.getActionCommand();

if("开始译码" == s){

ta.append("译码结果为："+"\n");

String get_yima;

get_yima=tf3.getText();

char yima_array[];

yima_array=get_yima.toCharArray();

String str=String.valueOf(yima_array[0]);

for(int i=0;i

for(int j=0;j

//System.out.println(str);

if(str.equals(node_array[j].code)&&node_array[j].name!='*'){

ta.append(String.valueOf(node_array[j].name));

str="";

//System.out.println("0");

break;

}

}

if(i<=yima_array.length-2){

str=str+String.valueOf(yima_array[i+1]);

}

}

}

}

}

六、源程序

import javax.swing.*;

import java.awt.Color;

import java.awt.event.*;

class HuffmanNode { //建立Huffman编码结点

public int frequency;

public boolean flag;

public char name;

public String code;

public HuffmanNode next;

HuffmanNode(char name,int frequency,boolean flag){

https://www.360docs.net/doc/3a8606956.html,=name;

this.frequency=frequency;

this.flag=flag;

this.code="";

this.next=null;

}

}

class N_Huffman_Jframe extends JFrame{

static public int n;

static public int sum;

static public int real_sum;

static public char sign[]=new char[50];//存放输入的符号

static public int times[]=new int[50];

ButtonListener bl =new ButtonListener();

ButtonListener2 b2 =new ButtonListener2();

JTextField tf1=new JTextField();

JTextField tf2=new JTextField();

JTextField tf3=new JTextField();

JTextArea ta=new JTextArea();

///////////////////////////////////////////////////////////// N_Huffman_Jframe(String title){

super(title);

this.setSize(500,360);

this.setLocation(400, 200);

addWindowListener( // 窗口监听器

new WindowAdapter() {

public void windowClosing(WindowEvent e) { // 关闭所有窗体

System.exit(0);

}

}

);

JPanel p=new JPanel();

p.setLayout(null);

JLabel l1=new JLabel("请输入符号序列");

l1.setFont(new java.awt.Font("微软雅黑",4,15));

l1.setBounds(10, 13, 120,20);

tf1.setBounds(125, 10,350, 30);

JLabel l2=new JLabel("元数");

l2.setBounds(355, 58, 50,20);

l2.setFont(new java.awt.Font("微软雅黑",4,15));

tf2.setBounds(395,55,80, 30);

JButton ok=new JButton("确认");

ok.setBounds(355, 100, 120, 35);

ok.setBackground(Color.white);

ok.setFont(new java.awt.Font("微软雅黑",4,15));

ok.addActionListener(bl);

JLabel l4=new JLabel("需要译码序列");

l4.setFont(new java.awt.Font("微软雅黑",4,15));

l4.setBounds(10, 250, 90, 20);

tf3.setBounds(110, 245, 365, 30);

JButton yima=new JButton("开始译码");

yima.setBounds(170, 282, 200, 30);

yima.setBackground(Color.white);

yima.setFont(new java.awt.Font("微软雅黑",4,15));

yima.addActionListener(b2);

ta.setBounds(15, 50, 330, 180);

ta.setLineWrap(true);

JScrollPane jsp=new JScrollPane(ta);

jsp.setBounds(15, 50, 330, 180);

this.add(p);

p.add(l1);

p.add(tf1);

p.add(l2);

p.add(tf2);

p.add(ok);

p.add(l4);

p.add(tf3);

p.add(yima);

p.add(jsp);

this.setVisible(true);

}

//////////////////////////////////////////////递归函数public void encode(HuffmanNode hn){

if(hn.next!=null&&hn.next.code!=null){

if(hn.next.flag!=false){

encode(hn.next);

hn.code=hn.next.code+hn.code;

hn.flag=false;

}

else

hn.code= hn.next.code +hn.code;

//System.out.println(hn.code);

}

}

HuffmanNode node_array[]=new HuffmanNode[200];

class ButtonListener implements ActionListener{ public void actionPerformed(ActionEvent e){ String s = e.getActionCommand();

if("确认" == s){

ta.setText("");

String str=tf1.getText();

String str2=tf2.getText();

n=Integer.parseInt(str2);

char get_sign[]=str.toCharArray();

sign[0]=get_sign[0];

//////////////////////计算输入的符号数

int jj=0;//sum = 1;

for(int i=0;i

int t=0;

for(int m=0;m

if(sign[m]!=get_sign[i])t++;

}

if(t==jj){

sign[jj]=get_sign[i];

jj++;//符号数

}

}

sum=jj;

//System.out.println(sign);//sign 为符号数组

//System.out.println("符号数为："+sum+"\n");

//////////////////////////////////////////////////////计算真实需要的符号数

for(int i=0;i

times[i]=0;

for(int i=0;i

for(int j=0;j

if (sign[i]==get_sign[j])times[i]++;

}

//System.out.print(times[i]+" ");

}

for(int i=0;;){

if((real_sum=i*(n-1)+n)

else break;

}

//System.out.println("\n"+"huffman编码需要的符号数："+real_sum);

//System.out.println("");

///////////////////////////////////////////////////建立Huffman结点数组

int ii;

int cha=real_sum-sum;

for(ii=0;ii

node_array[ii]=new HuffmanNode('*',0,false);

}

for(;ii

node_array[ii]=new

HuffmanNode(sign[ii-cha],times[ii-cha],false);

}

/*for(int i=0;i

System.out.println(node_array[i].name+"

"+node_array[i].frequency+" "+node_array[i].flag);

}*/

////////////////////////////////////////////////////开始编码…………………………

int circle_times=1;//记录while循环的次数

while(true){

int count=0;

int count2=0;

int combine=0;//每次n个符号频率相加的值

int false_num=0;

for(int i=0;i

if(node_array[i].flag==false)

false_num++;

}

//////////////////////////////////////////对HUFFMAN 结点数组进行排序

if(circle_times==1){

for(int i=0;i

for(int j=i+1;j

if(node_array[i].frequency>node_array[j].frequency){

HuffmanNode x;

x=node_array[i];

node_array[i]=node_array[j];

node_array[j]=x;

}

}

}

}

if(circle_times!=1){

int j=real_sum-1;

for(int i=real_sum-2;i>=0;i--){

if(node_array[i].frequency>node_array[j].frequency){

HuffmanNode x;

x=node_array[i];

node_array[i]=node_array[j];

node_array[j]=x;

j--;

}

}

}

//输出排序

/*for(int i=0;i

System.out.println(node_array[i].name+"

"+node_array[i].frequency+" "+node_array[i].flag);

}

System.out.print("\n");*/

//////////////////////////////////////////给每个符号的码符号

for(int i=0;i

if(count2!=n&&node_array[i].flag==false){

String temp=null;

temp=Integer.toString(count2);

//System.out.println(temp);

node_array[i].code=temp;

//System.out.println(node_array[i].name+" "+node_array[i].code);

count2++;

}

}

//////////////////////////////////////// 合并n个符号！！！！！

node_array[real_sum]=new

HuffmanNode('*',combine,false);//建立新的huffman结点

for(int i=0;i

if(count!=n&&node_array[i].flag==false&&false_num!=n){

combine=combine+node_array[i].frequency;

count++;

node_array[i].flag=true;

node_array[i].next=node_array[real_sum];

//System.out.println(node_array[i].name+" "+node_array[i].next.frequency);

}

}

//System.out.println(combine);

node_array[real_sum].frequency=combine;

real_sum++;

/////////////////////////////////////////////////////

if(false_num==n)

break;

circle_times++;

}

///////////////////////////////////////////////////////// for(int i=0;i

node_array[i].flag=true;

for(int i=0;i

encode(node_array[i]);

}

//System.out.println("");

for(int i=0;i

if(node_array[i].name!='*'){

ta.append(node_array[i].name+"

"+node_array[i].code);

ta.append("\n");

}

}

/*for(int i=0;i

if(node_array[i].next!=null)

System.out.println(node_array[i].name+" "+node_array[i].next.frequency);

}*/

for(int i=0;i

for(int j=0;j

if(get_sign[i]==node_array[j].name){

ta.append(node_array[j].code);

}

}

}

ta.append("\n");

}

}

}

class ButtonListener2 implements ActionListener{ public void actionPerformed(ActionEvent e){

String s = e.getActionCommand();

if("开始译码" == s){

ta.append("译码结果为："+"\n");

String get_yima;

get_yima=tf3.getText();

char yima_array[];

yima_array=get_yima.toCharArray();

String str=String.valueOf(yima_array[0]);

for(int i=0;i

for(int j=0;j

//System.out.println(str);

if(str.equals(node_array[j].code)&&node_array[j].name!='*'){

ta.append(String.valueOf(node_array[j].name));

str="";

//System.out.println("0");

break;

}

}

if(i<=yima_array.length-2){

str=str+String.valueOf(yima_array[i+1]);

}

}

}

}

}

}

public class n_huffman_encode {

public static void main(String args[]){

N_Huffman_Jframe nhj=new N_Huffman_Jframe("n元Huffman编码");

}

}

七、测试情况

本程序测试结果符合实际，正确的输出了输入信源符号的Huffman编码并正确译码。

实验三：对一灰度图像进行与Huffman结合的游程编码

的设计实现

一、问题描述

游程编码又称“运行长度编码”或“行程编码”，是一种统计编码，该编码属于无损压缩编码，是栅格数据压缩的重要编码方法。对于二值图有效。

游程编码的基本原理是：用一个符号值或串长代替具有相同值的连续符号，使符号长度少于原始数据的长度。只在各行或者各列数据的代码发生变化时，一次记录该代码及相同代码重复的个数，从而实现数据的压缩。

本次课程设计主要是实现对任意的符号序列进行游程编码，并将游程编码与Huffman 编码、等长编码进行结合。最后再将得到的编码结果进行译码，输出原来的符号序列。

二、基本要求

本程序需要达到的要求是：由使用者输入灰度图像矩阵的行数（m）、列（n）以及数灰度图像矩阵序列（如：5553444444332322）。后运行程序，程序输出与Huffman编码、等长编码结合的又称编码。再将编码结果输入，译码得出原矩阵。

三、测试数据

1.

输入行数：3 列数：3 灰度图像矩阵为：111222333

四、算法思想

本程序编码的算法思想如下：

（1）将输入的序列存入二维数组，并以行为单位记录符号出现的个数。

（2）将符号名以及出现次数记录到rlc_node数组；

（3）将rlc_node数组中的符号名进行Huffman编码，出现次数进行等长编码；

（4）输出结果。

本程序译码的算法思想如下：

（1）首先，声明一个标识，f=1时进行Huffman译码，其思想同实验一，译码之后将f=0；

（2）当f=0时，进行等长编码译码，将等长编码的二进制转换成十进制，输出结果并将f=1，如此循环下去，直到译完所有的码符号序列。

五、模块划分

1.建立游程编码结点

class rlc_node{

public int name;

public int times;

rlc_node(){

https://www.360docs.net/doc/3a8606956.html,=0;

this.times=0;

}

rlc_node(int name,int times){

https://www.360docs.net/doc/3a8606956.html,=name;

this.times=times;

}

}

2.建立等长编码结点

class dc_node{

public String name;

public int code_array[];

public String code;

public int length;

dc_node(){

this.code_array=new int[50];

https://www.360docs.net/doc/3a8606956.html,="";

this.length=0;

this.code="";

for(int i=0;i<50;i++)

this.code_array[i]=0;

}

}

3. 将矩阵存入二维数组

int a[][]=new int[m][n];//存放矩阵

int count1;

int ii;

int jj;

String get=tf4.getText();

char get1[]=get.toCharArray();

//System.out.println(get1.length);

for(count1=0;count1

for(ii=0;ii

for(jj=0;jj

String temp;

temp=String.valueOf(get1[count1]);

count1++;

a[ii][jj]=Integer.parseInt(temp);

//System.out.print(temp);

}

}

}

4. 形成数对

rlc_node node_array[]=new rlc_node[n*m];

for(int i=0;i

int count2=1;

for(int j=0;j

if(a[i][j]==a[i][j+1]){

count2++;

if(j+1==n-1){

node_array[num]=new

rlc_node(a[i][j],count2);

count2=1;

num++;

}

}

else{

node_array[num]=new

rlc_node(a[i][j],count2);

count2=1;

num++;

if(j+1==n-1){

node_array[num]=new

rlc_node(a[i][j+1],1);

count2=1;

num++;

}

}

}

}

5. 进行等长编码

for(int i=0;i

int p;

int q=Integer.parseInt(bb[i].name);

int j=0;

int count_length=0;

if(q!=0){

while(q!=0){

p=q%2;

bb[i].code_array[j]=p;

j++;

q=q/2;

count_length++;//确定等长编码编码长度

}

bb[i].length=count_length;

}

}

for(int i=0;i

if(max_length

max_length=bb[i].length;

}

for(int i=0;i

for(int j=max_length-1;j>=0;j--){

bb[i].code=bb[i].code+bb[i].code_array[j];

}

//System.out.println(bb[i].code);

}

6.进行译码

public void actionPerformed(ActionEvent e){

String s = e.getActionCommand();

if("开始译码"== s){

rlc_node yima_array[]=new rlc_node[num];

ta.append("译码如下："+"\n");

char get_yima[];

get_yima=ta2.getText().toCharArray();

String str="";

int f=1;

rlc_node dd[]=new rlc_node[num];

int dd_num=0;

for(int i=0;i

if(f==1){//huffman

for(int j=0;j

if(str.equals(node_array_h[j].code)&&node_array_h[j].name!='*'){

ta.append(String.valueOf(node_array_h[j].name));

dd[dd_num]=new rlc_node();

dd[dd_num].name=Integer.parseInt(String.valueOf(node_array_h[j].n ame));

str="";

f=0;

i=i-1;

break;

}

}

if(i<=get_yima.length-2&&f==1){

str=str+String.valueOf(get_yima[i]);

}

}

else{

if(i

String str2="";

for(int j=0;j

str2=str2+get_yima[i];

i++;

}

i=i-1;

for(int j=0;j

if(str2.equals(cc[j].code)){

ta.append(cc[j].name);

dd[dd_num].times=Integer.parseInt(cc[j].name);

dd_num++;

break;

}

}

//i=i-1;

f=1;

}

}

}

ta.append("\n");

ta.append("矩阵为：");

for(int i=0;i

for(int j=0;j

ta.append(String.valueOf(dd[i].name));

}

}

ta.append("\n");

}

}

六、源程序

import java.awt.Color;

import java.awt.event.*;

import javax.swing.*;

class HuffmanNode2 {

public int frequency;

public boolean flag;

public char name;

public String code;

public HuffmanNode2 next;

HuffmanNode2(char name,int frequency,boolean flag){ https://www.360docs.net/doc/3a8606956.html,=name;

this.frequency=frequency;

this.flag=flag;

this.code="";

this.next=null;

}

}

class rlc_node{

public int name;

public int times;

rlc_node(){

https://www.360docs.net/doc/3a8606956.html,=0;

this.times=0;