java 使用优先级队列的霍夫曼编码(Huffman Coding using Priority Queue)

最新推荐文章于 2025-12-01 18:34:47 发布

原创最新推荐文章于 2025-12-01 18:34:47 发布 · 1.9w 阅读

25 ·

CC 4.0 BY-SA版权

文章标签：

#java #算法 #数据结构

java 专栏收录该内容

116 篇文章

订阅专栏

先决条件：贪婪算法 | (霍夫曼编码)、priority_queue::push() 和 C++ STL 中的 priority_queue::pop() 。

贪婪算法 | (霍夫曼编码)：

C#：C# 霍夫曼编码 | 贪婪算法（Huffman Coding | Greedy Algo）-优快云博客

JavaScript：JavaScript 霍夫曼编码 | 贪婪算法（Huffman Coding | Greedy Algo）-优快云博客

python：python 霍夫曼编码 | 贪婪算法（Huffman Coding | Greedy Algo）-优快云博客

java：java 霍夫曼编码 | 贪婪算法（Huffman Coding | Greedy Algo）-优快云博客

c++ STL：c++ STL 霍夫曼编码 | 贪婪算法（Huffman Coding | Greedy Algo）-优快云博客

c++：c++ 霍夫曼编码 | 贪婪算法（Huffman Coding | Greedy Algo）_霍夫曼的贪婪算法设计核心代码-优快云博客

c语言：c语言霍夫曼编码 | 贪婪算法（Huffman Coding | Greedy Algo）_霍夫曼的贪婪c语言-优快云博客

priority_queue::push() 和 C++ STL 中的 priority_queue::pop() ：

C++ STL 中的 priority_queue::push() 和 priority_queue::pop()-优快云博客

给定一个字符数组 ch[]和每个字符的频率作为freq[] 。任务是使用优先级队列为ch[]中的每个字符找到霍夫曼编码。

例子

输入： ch[] = { 'a', 'b', 'c', 'd', 'e', 'f' }, freq[] = { 5, 9, 12, 13, 16, 45 }
输出：
f 0
c 100
d 101
a 1100
b 1101
e 111

方法：

   1、将ch[]中所有映射到相应频率freq[]的字符推入优先级队列。

   2、要创建哈夫曼树，请从优先级队列中弹出两个节点。

   3、将从优先级队列中弹出的两个节点指定为新节点的左子节点和右子节点。

   4、将新形成的节点推送到优先级队列中。

   5、重复以上所有步骤，直到优先级队列的大小变为 1。

   6、遍历哈夫曼树（其根是优先级队列中剩下的唯一节点）以存储哈夫曼代码

   7、打印ch[]中每个字符的所有存储的哈夫曼编码。

下面是上述方法的实现：

import java.util.*;

class HuffmanTreeNode
implements Comparable<HuffmanTreeNode>
{

// Stores character
char data;

// Stores frequency of the character
int freq;

// Left child of the current node
HuffmanTreeNode left;

// Right child of the current node
HuffmanTreeNode right;

public HuffmanTreeNode(char character, int frequency)
{
data = character;
freq = frequency;
left = right = null;
}

public int compareTo(HuffmanTreeNode other)
{
return freq - other.freq;
}
}

class HuffmanCodes {

// Maximum Height of Huffman Tree.
static final int MAX_SIZE = 100;

// Function to print the huffman code for each
// character. It uses arr to store the codes
static void printCodes(HuffmanTreeNode root, int[] arr,
int top)
{
// Assign 0 to the left node and recur
if (root.left != null) {
arr[top] = 0;
printCodes(root.left, arr, top + 1);
}

// Assign 1 to the right node and recur
if (root.right != null) {
arr[top] = 1;
printCodes(root.right, arr, top + 1);
}

// If this is a leaf node, then we print root.data
// We also print the code for this character from
// arr
if (root.left == null && root.right == null) {
System.out.print(root.data + " ");
for (int i = 0; i < top; ++i) {
System.out.print(arr[i]);
}
System.out.println();
}
}

// Function to generate Huffman Encoding Tree
static HuffmanTreeNode
generateTree(PriorityQueue<HuffmanTreeNode> pq)
{

// We keep on looping till only one node remains in
// the Priority Queue
while (pq.size() != 1) {

// Node which has least frequency
HuffmanTreeNode left = pq.poll();

// Node which has least frequency
HuffmanTreeNode right = pq.poll();

// A new node is formed with frequency left.freq
// + right.freq We take data as '$' because we
// are only concerned with the frequency
HuffmanTreeNode node = new HuffmanTreeNode(
'$', left.freq + right.freq);
node.left = left;
node.right = right;

// Push back node created to the Priority Queue
pq.add(node);
}

return pq.poll();
}

// Function to generate Huffman Codes
static void HuffmanCodes(char[] data, int[] freq,
int size)
{
// Declaring priority queue using custom comparator
PriorityQueue<HuffmanTreeNode> pq
= new PriorityQueue<>();

// Populating the priority queue
for (int i = 0; i < size; i++) {
HuffmanTreeNode newNode
= new HuffmanTreeNode(data[i], freq[i]);
pq.add(newNode);
}

// Generate Huffman Encoding Tree and get the root
// node
HuffmanTreeNode root = generateTree(pq);

// Print Huffman Codes
int[] arr = new int[MAX_SIZE];
int top = 0;
printCodes(root, arr, top);
}

// Driver Code
public static void main(String[] args)
{
char[] data = { 'a', 'b', 'c', 'd', 'e', 'f' };
int[] freq = { 5, 9, 12, 13, 16, 45 };
int size = data.length;

// Function call
HuffmanCodes(data, freq, size);
}
}