哈夫曼编码压缩及解压文件（C语言及Java实现）
哈夫曼编码压缩及解压文件（C语言及Java实现）
-
- 设计说明
- 实现说明
- Java实现的简单文本压缩及解压
- Java的文件压缩及解压
- Java带界面的文件压缩与解压
- C语言的压缩及解压
- C语言压缩解压文件的完整流程
- 带界面的Winform调用exe程序的哈夫曼压缩小程序
- 代码下载
- Gitee链接
设计说明
哈夫曼编码作为压缩里面的无损压缩，还是很经典的；在数据结构中树章节，哈夫曼树的主要应用也是作为最小生成树来编码内容，来达到压缩的效果
以较为简单的压缩文本开始，到后面进行文件IO操作，来压缩及解压文件（包括文本文件与图片文件等）
在C语言实现的过程中遇到了问题，所以有好几版代码，可以直接下载最新的代码，贴在文章中的不是最好的代码，是有bug的
实现说明
实现思路：
1、获取文本编码的频率，得到Map集合，后通过哈夫曼树生成算法，生成哈夫曼树（生成哈夫曼树的算法其实很简单，就重复两个步骤，排序，取前面最小的两个结点的组成一个新的结点，删除选择的两个结点，添加新生成的结点，重复这个过程，直到只剩下最后一个节点，即生成好了哈夫曼树）
2、通过哈夫曼树得到哈夫曼编码，然后采用哈夫曼编码对文本字节数组进行转化为二进制字符串，然后再转化为新的字节数组
3、得到相应的解压编码，然后根据压缩后的字节数组还原得到编码的二进制串，还原为原来的字符即可
Java实现的简单文本压缩及解压
步骤与上述说明的一致，代码函数命名较为清晰，就没有写注释了，相信是可以看的明白的
package test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
/**
* @author bbyh
* @date 2023/4/5 0005 21:46
* @description
*/
public class Hoffman {
private static final HashMap<Byte, String> ENCODE_MAP = new HashMap<>();
private static final HashMap<String, Byte> DECODE_MAP = new HashMap<>();
private static Integer LENGTH_OF_BIT;
public static void main(String[] args) {
String text = "你好，今天天气不错";
HashMap<Byte, Integer> twoTuple = getTwoTuple(text.getBytes());
ArrayList<Node> nodeList = getListNode(twoTuple);
Node root = generateHoffmanTree(nodeList);
getEncodeMap(root, "");
String binaryString = getZipBinaryString(text.getBytes());
byte[] byteArr = zipToByteArr(binaryString);
getDecodeMap();
String unZipBinaryString = getUnZipBinaryString(byteArr);
String originText = unZipToOriginText(unZipBinaryString, text.getBytes().length);
System.out.println(originText);
}
private static String unZipToOriginText(String unZipBinaryString, int textBytesLength) {
int index;
int length = unZipBinaryString.length();
byte[] buf = new byte[textBytesLength];
int count = 0;
for (int i = 0; i < length; ) {
index = 1;
while (index + i <= LENGTH_OF_BIT) {
String substring = unZipBinaryString.substring(i, i + index);
if (DECODE_MAP.containsKey(substring)) {
buf[count++] = DECODE_MAP.get(substring);
break;
}
index++;
}
i += index;
}
return new String(buf);
}
private static String getUnZipBinaryString(byte[] byteArr) {
StringBuilder builder = new StringBuilder();
for (byte b : byteArr) {
builder.append(Integer.toBinaryString((b & 0xFF) + 0x100).substring(1));
}
return builder.toString();
}
private static void getDecodeMap() {
for (Byte b : ENCODE_MAP.keySet()) {
DECODE_MAP.put(ENCODE_MAP.get(b), b);
}
}
private static byte[] zipToByteArr(String byteString) {
LENGTH_OF_BIT = byteString.length();
StringBuilder byteStringBuilder = new StringBuilder(byteString);
for (int i = 0; i < byteStringBuilder.length() % 8; i++) {
byteStringBuilder.append("0");
}
byteString = byteStringBuilder.toString();
int length = byteString.length();
int index = 0;
byte[] byteArr = new byte[length / 8];
while (index < byteArr.length) {
byteArr[index] = (byte) (Integer.parseInt(byteString.substring(8 * index, 8 * (index + 1)), 2));
index++;
}
return byteArr;
}
private static String getZipBinaryString(byte[] bytes) {
StringBuilder builder = new StringBuilder();
for (byte b : bytes) {
builder.append(ENCODE_MAP.get(b));
}
return builder.toString();
}
private static void getEncodeMap(Node root, String s) {
if (root == null) {
return;
} else if (root.left == null && root.right == null) {
ENCODE_MAP.put(root.data, s);
}
if (root.left != null) {
getEncodeMap(root.left, s + "0");
}
if (root.right != null) {
getEncodeMap(root.right, s + "1");
}
}
private static Node generateHoffmanTree(ArrayList<Node> nodeList) {
while (nodeList.size() > 1) {
Collections.sort(nodeList);
Node leftNode = nodeList.get(0);
Node rightNode = nodeList.get(1);
Node root = new Node(null, leftNode.value + rightNode.value);
root.left = leftNode;
root.right = rightNode;
nodeList.remove(1);
nodeList.remove(0);
nodeList.add(root);
}
return nodeList.get(0);
}
private static ArrayList<Node> getListNode(HashMap<Byte, Integer> twoTuple) {
ArrayList<Node> nodeList = new ArrayList<>();
for (Byte b : twoTuple.keySet()) {
Node node = new Node(b, twoTuple.get(b));
nodeList.add(node);
}
return nodeList;
}
private static HashMap<Byte, Integer> getTwoTuple(byte[] bytes) {
HashMap<Byte, Integer> twoTuple = new HashMap<>();
for (byte b : bytes) {
if (twoTuple.containsKey(b)) {
twoTuple.replace(b, twoTuple.get(b) + 1);
} else {
twoTuple.put(b, 1);
}
}
return twoTuple;
}
static class Node implements Comparable<Node> {
Byte data;
int value;
Node left;
Node right;
public Node(Byte data, int value) {
this.data = data;
this.value = value;
}
@Override
public String toString() {
return "Node{" +
"data=" + data +
", value=" + value +
'}';
}
@Override
public int compareTo(Node o) {
return this.value - o.value;
}
}
}
演示效果：
英文肯定更没问题
Java的文件压缩及解压
在明白了上述文本的压缩，实际文件的压缩和解压也是一致的，都可以转化为byte数组
只是需要添加一些文件IO的操作
package test;
import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
/**
* @author bbyh
* @date 2023/4/5 0005 21:46
* @description
*/
public class Hoffman {
private static final HashMap<Byte, String> ENCODE_MAP = new HashMap<>();
private static final HashMap<String, Byte> DECODE_MAP = new HashMap<>();
private static Integer LENGTH_OF_BIT;
public static void main(String[] args) {
String originFileName = "D:/test.txt";
byte[] textBytes = getBytesFromFile(originFileName);
if (textBytes == null) {
System.out.println("当前字节数组为空，无法压缩与解压");
return;
}
HashMap<Byte, Integer> twoTuple = getTwoTuple(textBytes);
ArrayList<Node> nodeList = getListNode(twoTuple);
Node root = generateHoffmanTree(nodeList);
getEncodeMap(root, "");
String binaryString = getZipBinaryString(textBytes);
byte[] byteArr = zipToByteArr(binaryString);
String zipFileName = "D:/test.myZip";
generateZipFile(zipFileName, byteArr);
getDecodeMap();
String unZipBinaryString = getUnZipBinaryString(byteArr);
String unZipFileName = "D:/test1.txt";
unZipToOriginText(unZipBinaryString, textBytes.length, unZipFileName);
System.out.println("压缩与解压完成");
}
private static void generateZipFile(String zipFileName, byte[] byteArr) {
try (FileOutputStream outputStream = new FileOutputStream(zipFileName)) {
outputStream.write(byteArr);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private static byte[] getBytesFromFile(String originFileName) {
File file = new File(originFileName);
if (!file.exists()) {
return null;
}
try (FileInputStream inputStream = new FileInputStream(originFileName)) {
int available = inputStream.available();
byte[] buf = new byte[available];
inputStream.read(buf);
return buf;
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private static void unZipToOriginText(String unZipBinaryString, int textBytesLength, String unZipFileName) {
int index;
int length = unZipBinaryString.length();
byte[] buf = new byte[textBytesLength];
int count = 0;
for (int i = 0; i < length; ) {
index = 1;
while (index + i <= LENGTH_OF_BIT) {
String substring = unZipBinaryString.substring(i, i + index);
if (DECODE_MAP.containsKey(substring)) {
buf[count++] = DECODE_MAP.get(substring);
break;
}
index++;
}
i += index;
}
try (FileOutputStream outputStream = new FileOutputStream(unZipFileName)) {
outputStream.write(buf);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private static String getUnZipBinaryString(byte[] byteArr) {
StringBuilder builder = new StringBuilder();
for (byte b : byteArr) {
builder.append(Integer.toBinaryString((b & 0xFF) + 0x100).substring(1));
}
return builder.toString();
}
private static void getDecodeMap() {
for (Byte b : ENCODE_MAP.keySet()) {
DECODE_MAP.put(ENCODE_MAP.get(b), b);
}
}
private static byte[] zipToByteArr(String byteString) {
LENGTH_OF_BIT = byteString.length();
StringBuilder byteStringBuilder = new StringBuilder(byteString);
for (int i = 0; i < byteStringBuilder.length() % 8; i++) {
byteStringBuilder.append("0");
}
byteString = byteStringBuilder.toString();
int length = byteString.length();
int index = 0;
byte[] byteArr = new byte[length / 8];
while (index < byteArr.length) {
byteArr[index] = (byte) (Integer.parseInt(byteString.substring(8 * index, 8 * (index + 1)), 2));
index++;
}
return byteArr;
}
private static String getZipBinaryString(byte[] bytes) {
StringBuilder builder = new StringBuilder();
for (byte b : bytes) {
builder.append(ENCODE_MAP.get(b));
}
return builder.toString();
}
private static void getEncodeMap(Node root, String s) {
if (root == null) {
return;
} else if (root.left == null && root.right == null) {
ENCODE_MAP.put(root.data, s);
}
if (root.left != null) {
getEncodeMap(root.left, s + "0");
}
if (root.right != null) {
getEncodeMap(root.right, s + "1");
}
}
private static Node generateHoffmanTree(ArrayList<Node> nodeList) {
while (nodeList.size() > 1) {
Collections.sort(nodeList);
Node leftNode = nodeList.get(0);
Node rightNode = nodeList.get(1);
Node root = new Node(null, leftNode.value + rightNode.value);
root.left = leftNode;
root.right = rightNode;
nodeList.remove(1);
nodeList.remove(0);
nodeList.add(root);
}
return nodeList.get(0);
}
private static ArrayList<Node> getListNode(HashMap<Byte, Integer> twoTuple) {
ArrayList<Node> nodeList = new ArrayList<>();
for (Byte b : twoTuple.keySet()) {
Node node = new Node(b, twoTuple.get(b));
nodeList.add(node);
}
return nodeList;
}
private static HashMap<Byte, Integer> getTwoTuple(byte[] bytes) {
HashMap<Byte, Integer> twoTuple = new HashMap<>();
for (byte b : bytes) {
if (twoTuple.containsKey(b)) {
twoTuple.replace(b, twoTuple.get(b) + 1);
} else {
twoTuple.put(b, 1);
}
}
return twoTuple;
}
static class Node implements Comparable<Node> {
Byte data;
int value;
Node left;
Node right;
public Node(Byte data, int value) {
this.data = data;
this.value = value;
}
@Override
public String toString() {
return "Node{" +
"data=" + data +
", value=" + value +
'}';
}
@Override
public int compareTo(Node o) {
return this.value - o.value;
}
}
}
压缩文本文件演示
压缩图片文件演示
压缩音频文件演示（直接堆内存溢出了，说明算法是有问题的，需要改进，不能单纯的用字符串进行运算；但也不是每次都会堆溢出，但发现的新问题就是压缩率不高，且压缩效率较慢）
Java带界面的文件压缩与解压
前面两个文件的压缩与解压都只是演示，并不是正常的完整流程，正常流程中，压缩的文件内是需要将encodeMap一同写入的，然后解压的时候再读出来
下面是完整流程代码
package test;
import javax.swing.*;
import java.awt.*;
import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
/**
* @author bbyh
* @date 2023/4/5 0005 23:40
* @description
*/
public class HoffmanMainFrame extends JFrame {
private static Zip zip = new Zip();
public HoffmanMainFrame(String title) {
setTitle(title);
setSize(500, 200);
setLocationRelativeTo(null);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLayout(null);
Font font = new Font("楷体", Font.BOLD, 20);
JLabel label = new JLabel("暂未选择文件", SwingConstants.CENTER);
JButton chooseFile = new JButton("选择文件");
JButton zip = new JButton("压缩");
JButton unZip = new JButton("解压");
add(label);
add(chooseFile);
add(zip);
add(unZip);
label.setFont(font);
chooseFile.setFont(font);
zip.setFont(font);
unZip.setFont(font);
label.setBounds(30, 20, 440, 40);
chooseFile.setBounds(40, 100, 120, 40);
zip.setBounds(180, 100, 120, 40);
unZip.setBounds(320, 100, 120, 40);
chooseFile.addActionListener(e -> {
JFileChooser fileChooser = new JFileChooser(new File("D:\\"));
fileChooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
fileChooser.showOpenDialog(null);
File selectedFile = fileChooser.getSelectedFile();
label.setText(selectedFile.getAbsolutePath());
});
zip.addActionListener(e -> {
String originFileName = label.getText();
byte[] textBytes = getBytesFromFile(originFileName);
if (textBytes == null) {
JOptionPane.showMessageDialog(null, "当前字节数组为空，无法压缩");
return;
}
HashMap<Byte, Integer> twoTuple = getTwoTuple(textBytes);
ArrayList<Node> nodeList = getListNode(twoTuple);
Node root = generateHoffmanTree(nodeList);
getEncodeMap(root, "");
String binaryString = getZipBinaryString(textBytes);
byte[] byteArr = zipToByteArr(binaryString);
String zipFileName = originFileName.substring(0, originFileName.lastIndexOf(".")) + ".myZip";
generateZipFile(zipFileName, byteArr);
JOptionPane.showMessageDialog(null, "压缩完成");
});
unZip.addActionListener(e -> {
String originFileName = label.getText();
String zipFileName = originFileName.substring(0, originFileName.lastIndexOf(".")) + ".myZip";
String unZipBinaryString = getUnZipBinaryString(zipFileName);
String unZipFileName = "D:/test1.txt";
unZipToOriginText(unZipBinaryString, unZipFileName);
JOptionPane.showMessageDialog(null, "解压完成");
});
}
public static void main(String[] args) {
new HoffmanMainFrame("哈夫曼压缩与解压工具").setVisible(true);
}
static class Zip implements Serializable {
private static final long serialVersionUID = 1L;
HashMap<Byte, String> encodeMap = new HashMap<>();
final HashMap<String, Byte> decodeMap = new HashMap<>();
Integer lengthOfBit;
Integer lengthOfTextBytes;
}
static class Node implements Comparable<Node> {
Byte data;
int value;
Node left;
Node right;
public Node(Byte data, int value) {
this.data = data;
this.value = value;
}
@Override
public String toString() {
return "Node{" +
"data=" + data +
", value=" + value +
'}';
}
@Override
public int compareTo(Node o) {
return this.value - o.value;
}
}
private static void unZipToOriginText(String unZipBinaryString, String unZipFileName) {
int index;
int length = unZipBinaryString.length();
byte[] buf = new byte[zip.lengthOfTextBytes];
int count = 0;
for (int i = 0; i < length; ) {
index = 1;
while (index + i <= zip.lengthOfBit) {
String substring = unZipBinaryString.substring(i, i + index);
if (zip.decodeMap.containsKey(substring)) {
buf[count++] = zip.decodeMap.get(substring);
break;
}
index++;
}
i += index;
}
try (FileOutputStream outputStream = new FileOutputStream(unZipFileName)) {
outputStream.write(buf);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private static String getUnZipBinaryString(String zipFileName) {
try (FileInputStream inputStream = new FileInputStream(zipFileName)) {
ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
zip = (Zip) objectInputStream.readObject();
zip.decodeMap.clear();
for (Byte b : zip.encodeMap.keySet()) {
zip.decodeMap.put(zip.encodeMap.get(b), b);
}
byte[] buf = new byte[(zip.lengthOfBit + 7) / 8];
System.out.println(inputStream.read(buf));
StringBuilder builder = new StringBuilder();
for (byte b : buf) {
builder.append(Integer.toBinaryString((b & 0xFF) + 0x100).substring(1));
}
return builder.toString();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private static void generateZipFile(String zipFileName, byte[] byteArr) {
try (FileOutputStream outputStream = new FileOutputStream(zipFileName)) {
ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
objectOutputStream.writeObject(zip);
outputStream.write(byteArr);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private static byte[] getBytesFromFile(String originFileName) {
File file = new File(originFileName);
if (!file.exists()) {
return null;
}
try (FileInputStream inputStream = new FileInputStream(originFileName)) {
int available = inputStream.available();
zip.lengthOfTextBytes = available;
byte[] buf = new byte[available];
System.out.println(inputStream.read(buf));
return buf;
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private static byte[] zipToByteArr(String byteString) {
zip.lengthOfBit = byteString.length();
StringBuilder byteStringBuilder = new StringBuilder(byteString);
for (int i = 0; i < byteStringBuilder.length() % 8; i++) {
byteStringBuilder.append("0");
}
byteString = byteStringBuilder.toString();
int length = byteString.length();
int index = 0;
byte[] byteArr = new byte[length / 8];
while (index < byteArr.length) {
byteArr[index] = (byte) (Integer.parseInt(byteString.substring(8 * index, 8 * (index + 1)), 2));
index++;
}
return byteArr;
}
private static String getZipBinaryString(byte[] bytes) {
StringBuilder builder = new StringBuilder();
for (byte b : bytes) {
builder.append(zip.encodeMap.get(b));
}
return builder.toString();
}
private static void getEncodeMap(Node root, String s) {
if (root == null) {
return;
} else if (root.left == null && root.right == null) {
zip.encodeMap.put(root.data, s);
return;
}
if (root.left != null) {
getEncodeMap(root.left, s + "0");
}
if (root.right != null) {
getEncodeMap(root.right, s + "1");
}
}
private static Node generateHoffmanTree(ArrayList<Node> nodeList) {
while (nodeList.size() > 1) {
Collections.sort(nodeList);
Node leftNode = nodeList.get(0);
Node rightNode = nodeList.get(1);
Node root = new Node(null, leftNode.value + rightNode.value);
root.left = leftNode;
root.right = rightNode;
nodeList.remove(1);
nodeList.remove(0);
nodeList.add(root);
}
return nodeList.get(0);
}
private static ArrayList<Node> getListNode(HashMap<Byte, Integer> twoTuple) {
ArrayList<Node> nodeList = new ArrayList<>();
for (Byte b : twoTuple.keySet()) {
Node node = new Node(b, twoTuple.get(b));
nodeList.add(node);
}
return nodeList;
}
private static HashMap<Byte, Integer> getTwoTuple(byte[] bytes) {
HashMap<Byte, Integer> twoTuple = new HashMap<>();
for (byte b : bytes) {
if (twoTuple.containsKey(b)) {
twoTuple.replace(b, twoTuple.get(b) + 1);
} else {
twoTuple.put(b, 1);
}
}
return twoTuple;
}
}
演示效果
C语言的压缩及解压
与Java类似的步骤；但是不一样的是，C语言的文件读写功能有许多点需要自己实现及注意
主要是读写文件的二进制读写问题
# include 演示效果
C语言压缩解压文件的完整流程
上述的压缩和解压是放在一起的
实际也应该在压缩文件时，一并将编码写入到压缩文件中；这里采用写入结构体的方式
# include 带界面的Winform调用exe程序的哈夫曼压缩小程序
考虑到分了两个步骤，所以将cpp文件也分为两个
在这个地方的测试，我发现原来的代码是有问题的；C语言对于结构体的读写不是这么简单的，那个map拿不到内容
结构体写入时需要写入数组，不能写入指针
这里采用写入字符出现频率的方式，在解压过程中重新构建一次哈夫曼树，得到同样的哈夫曼编码
采用这样的设计方式的原因是，写入可以更方便的读出；后续如果可能的话，将模拟Java序列化的方式解决这个问题
压缩
# include 解压
# include Winform的代码，调用命令行参数执行exe文件
using System;
using System.Diagnostics;
using System.Windows.Forms;
namespace HoffmanZip
{
public partial class 哈夫曼压缩与解压文件 : Form
{
public 哈夫曼压缩与解压文件()
{
InitializeComponent();
}
private void ChooseFile_Click(object sender, EventArgs e)
{
OpenFileDialog dialog = new OpenFileDialog
{
Multiselect = false,
Title = "请选择文件夹",
Filter = "所有文件(*.*)|*.*",
InitialDirectory = "D:\\"
};
if (dialog.ShowDialog() == DialogResult.OK)
{
label.Text = dialog.FileName;
}
}
private void Zip_Click(object sender, EventArgs e)
{
if (label.Text == "暂未选择文件")
{
MessageBox.Show("还未选择文件");
return;
}
string fileName = label.Text;
Process process = new Process();
ProcessStartInfo startInfo = new ProcessStartInfo("压缩.exe", fileName + " " + fileName + ".myZip");
process.StartInfo = startInfo;
process.Start();
MessageBox.Show("压缩成功");
}
private void UnZip_Click(object sender, EventArgs e)
{
if (label.Text == "暂未选择文件")
{
MessageBox.Show("还未选择文件");
return;
}
string fileName = label.Text;
if (!fileName.EndsWith(".myZip"))
{
MessageBox.Show("文件类型不匹配，需要为.myZip文件");
return;
}
Process process = new Process();
ProcessStartInfo startInfo = new ProcessStartInfo("解压.exe", fileName + " " + fileName.Substring(0, fileName.LastIndexOf(".")));
process.StartInfo = startInfo;
process.Start();
MessageBox.Show("解压成功");
}
}
}
效果演示
代码下载
链接：https://pan.baidu.com/s/16rZYDQUGxIRp2dJXmkldWg
提取码：0925
Gitee链接
https://gitee.com/anxwefndu/huffman-tree-encoding