2. 程式人生 > 其它 >哈夫曼樹與哈夫曼編碼

哈夫曼樹與哈夫曼編碼

阿新 • • 發佈：2021-02-02

技術標籤：演算法與資料結構資料結構c++

哈夫曼樹與哈夫曼編碼

哈夫曼樹

哈夫曼樹是一類帶權路徑長度最短的樹，通過對哈夫曼樹的構建，可以實現資料的編碼最短且不同資料編碼之間互不為前後綴的效果。

如何構建哈夫曼樹

  1. 根據給定的 n n n個權值 { v 1 , v 2 , … , v n } \{v_1,v_2,\dots,v_n \} {v1​,v2​,…,vn​}構造 n n n棵只有根節點的二叉樹，並令其權值為 w i ( i = 1 , 2 , … , n ) w_i (i =1,2,\dots ,n) wi
    ​    (i=    1,2,…,n)    。
  2. 在這些二叉樹所組成的森林中選取兩棵節點權值最小的樹分別為其左右子樹（約定左子樹權值不大於右子樹）構建一棵新的二叉樹。
  3. 在森林中刪除選中的兩棵樹，並將合併後的二叉樹加入森林中。
  4. 重複 2 、 3 2、3 2、3步，直至只有一棵二叉樹，即哈夫曼樹。

舉個例子：
給定五個資料 { A , B , C , D , E } \{A,B,C,D,E \} {A,B,C,D,E}，其權值分別為 { 1 , 3 , 5 , 2 , 4 } \{1,3,5,2,4 \} {1,3,5,2,4}：

構建哈夫曼樹

構建哈夫曼樹的實現

程式碼中，將哈夫曼樹儲存在vector中進行演示；
若使用陣列形式，可在建構函式內動態申請陣列空間（記得在解構函式中釋放）；
以下程式碼中使用了模板，其中K代表需要構建哈夫曼樹的資料的資料型別，V代表其權值的資料型別；

哈夫曼樹結構體的定義：

	struct HTNode {
		V value; //節點權值，用模板V代表其型別
		K data;//節點所帶資料
		int parent, lchild, rchild;//節點雙親及左右孩子下標
	};

由於哈夫曼樹中沒有度為 1 1 1的節點，則一棵具有 n n n個葉子節點的哈夫曼樹共有 2 n − 1 2n-1 2n−1個節點。
vector初始化：
擴容到 2 n − 1 2n-1 2n−1個空間，並將所有單元中的雙親及左右孩子的下標初始化為 − 1 -1 −1，並將前 n n n個單元的權值及資料儲存下來。
建立哈夫曼樹：
進行迴圈 n − 1 n-1

n−1次操作來實現選擇、刪除與合併操作來建立哈夫曼樹，其中：

  • 選擇：從當前森林中選擇出雙親為 − 1 -1 −1且權值最小的兩個樹的根節點 s 1 s1 s1和 s 2 s2 s2。
  • 刪除：將節點 s 1 s1 s1和 s 2 s2 s2的雙親修改為非 − 1 -1 −1。
  • 合併：將 s 1 s1 s1和 s 2 s2 s2的權值和作為一個新的節點的權值，依次存放到容器的第 n n n個之後的單元中，同時記錄下這個節點的左孩子下標 s 1 s1 s1和右孩子下標 s 2 s2 s2。

計算樹的帶權路徑長度：
可以通過遞迴的方式向下進行

  • 是葉子節點：返回該節點權值與深度乘積
  • 非葉子節點：返回其左右子樹的帶權路徑長度之和

選擇出最小節點的函式：

void getMin(int n, int& s1, int& s2) {
		s1 = s2 = -1;
		int i;
		//尋得兩個節點，並保證s1比s2節點小
		for (i = 0; i < n; i++) {
			if (ht[i].parent == -1) {
				if (s1 == -1) {
					s1 = i;
				}
				else {
					s2 = i;
					break;
				}
			}
		}
		if (ht[s1].value > ht[s2].value) {
			s1 ^= s2 ^= s1 ^= s2;
		}
		//尋找到最小的兩個節點，並保證s2不小於s1
		for (i += 1; i < n; i++) {
			if (ht[i].parent == -1) {
				if (ht[i].value < ht[s1].value) {
					s2 = s1;
					s1 = i;
				}
				else if (ht[i].value < ht[s2].value) {
					s2 = i;
				}
			}
		}
	}

計算帶權路徑長度的函式：

int huffmanTreeWPL(int i, int dep) {
		if (ht[i].lchild == -1 && ht[i].rchild == -1) {
			//葉子節點的權值為該點權值*該節點深度
			return ht[i].value * dep;
		}
		else {
			//非葉子節點的權值為其子樹權值之和
			return huffmanTreeWPL(ht[i].lchild, dep + 1) + huffmanTreeWPL(ht[i].rchild, dep + 1);
		}
	}

構建哈夫曼樹的函式：

HuffmanTree(vector<K>& HData, vector<V>& HValues) {
		dataNum = HData.size();
		maxNodes = dataNum * 2 - 1;
		ht.clear();
		//存入資料
		HTNode tempNode;
		tempNode.parent = tempNode.lchild = tempNode.rchild = -1;
		for (int i = 0; i < maxNodes; i++) {
			ht.push_back(tempNode);
		}
		for (int i = 0; i < dataNum; i++) {
			ht[i].value = HValues[i];
			ht[i].data = HData[i];
		}
		//構建哈夫曼樹
		for (int i = dataNum; i < maxNodes; i++) {
			int s1, s2;
			getMin(i, s1, s2);

			ht[s1].parent = ht[s2].parent = i;
			ht[i].lchild = s1;
			ht[i].rchild = s2;
			ht[i].value = ht[s1].value + ht[s2].value;
		}
		//計算帶權路徑長度
		WPL = huffmanTreeWPL(maxNodes - 1, 0);
	}

哈夫曼編碼

從根節點開始，左子樹編碼為"0"，右子樹編碼為"1"，從根節點到該節點所經過的編碼連起來就是該節點的哈夫曼編碼。
舉個例子：（對剛才構建的哈夫曼樹進行編碼）

進行哈夫曼編碼
**完成哈夫曼編碼：** 從葉子節點出發向上探尋，若為左孩子，則增加字首編碼"0"，若為右孩子，則增加字首編碼"1" *注：增加字首編碼的原因是哈夫曼編碼從根節點開始，而實現時從葉子節點開始，方向相反，故通過增加字首的方式實現編碼*

對資料進行哈夫曼編碼的函式：

void computedHuffmanCode() {
		string code;
		int parent;

		//從葉子節點獲得逆序哈夫曼編碼
		for (int i = 0; i < dataNum; i++) {
			int j = i;
			code = "";

			while (ht[j].parent != -1) {
				parent = ht[j].parent;
				if (j == ht[parent].lchild) {
					code = "0" + code;
				}
				else {
					code = "1" + code;
				}
				j = parent;
			}
			//存入map中方便查詢
			huffmanCode.insert(pair<K, string>(ht[i].data, code));
		}
	}

完整程式碼

#pragma once
#include <vector>
#include <map>
#include <string>

template <class K, class V>
class HuffmanTree {
public:
	/**
	  *建構函式
	  *根據HValues的權值構建哈夫曼樹
	  *根據構建好的哈夫曼樹計算帶權路徑長度(WPL)和哈夫曼編碼
	  */
	HuffmanTree(std::vector<K>& HData, std::vector<V>& HValues) {
		dataNum = HData.size();
		maxNodes = dataNum * 2 - 1;
		ht.clear();
		//存入資料
		HTNode tempNode;
		tempNode.parent = tempNode.lchild = tempNode.rchild = -1;
		for (int i = 0; i < maxNodes; i++) {
			ht.push_back(tempNode);
		}
		for (int i = 0; i < dataNum; i++) {
			ht[i].value = HValues[i];
			ht[i].data = HData[i];
		}
		//構建哈夫曼樹
		for (int i = dataNum; i < maxNodes; i++) {
			int s1, s2;
			getMin(i, s1, s2);

			ht[s1].parent = ht[s2].parent = i;
			ht[i].lchild = s1;
			ht[i].rchild = s2;
			ht[i].value = ht[s1].value + ht[s2].value;
		}
		//計算帶權路徑長度
		WPL = huffmanTreeWPL(maxNodes - 1, 0);
		//計算哈夫曼編碼
		computedHuffmanCode();
	}
	/**
	  *返回帶權路徑長度
	  */
	int getWPL() {
		return this->WPL;
	}
	/**
	  *返回全部哈夫曼編碼
	  */
	std::map<K, std::string> getAllHuffmanCode() {
		return huffmanCode;
	}
	/**
	  *返回特定data的哈夫曼編碼
	  *該data不存在該哈夫曼樹中，返回空字串
	  */
	std::string getHuffmanCode(K data) {
		return huffmanCode.find(data) == huffmanCode.end() ? "" : huffmanCode[data];
	}


private:
	struct HTNode {
		V value;
		K data;
		int parent, lchild, rchild;
	};

	int dataNum;							//需要編碼的資料數量
	int maxNodes;							//樹需要的最多節點數量
	int WPL;								//帶權路徑長度
	std::vector<HTNode> ht;					//哈夫曼樹
	std::map<K, std::string> huffmanCode;	//哈夫曼編碼
	/**
	  *尋找當前兩個權值最小的樹
	  */
	void getMin(int n, int& s1, int& s2) {
		s1 = s2 = -1;
		int i;
		//尋得兩個節點，並保證s1比s2節點小
		for (i = 0; i < n; i++) {
			if (ht[i].parent == -1) {
				if (s1 == -1) {
					s1 = i;
				}
				else {
					s2 = i;
					break;
				}
			}
		}
		if (ht[s1].value > ht[s2].value) {
			s1 ^= s2 ^= s1 ^= s2;
		}
		//尋找到最小的兩個節點，並保證s2不小於s1
		for (i += 1; i < n; i++) {
			if (ht[i].parent == -1) {
				if (ht[i].value < ht[s1].value) {
					s2 = s1;
					s1 = i;
				}
				else if (ht[i].value < ht[s2].value) {
					s2 = i;
				}
			}
		}
	}
	/**
	  *計算帶權路徑長度
	  */
	int huffmanTreeWPL(int i, int dep) {
		if (ht[i].lchild == -1 && ht[i].rchild == -1) {
			//葉子節點的權值為該點權值*該節點深度
			return ht[i].value * dep;
		}
		else {
			//非葉子節點的權值為其子樹權值之和
			return huffmanTreeWPL(ht[i].lchild, dep + 1) + huffmanTreeWPL(ht[i].rchild, dep + 1);
		}
	}
	/**
	  *計算哈夫曼編碼
	  */
	void computedHuffmanCode() {
		std::string code;
		int parent;

		//從葉子節點獲得逆序哈夫曼編碼
		for (int i = 0; i < dataNum; i++) {
			int j = i;
			code = "";

			while (ht[j].parent != -1) {
				parent = ht[j].parent;
				if (j == ht[parent].lchild) {
					code = "0" + code;
				}
				else {
					code = "1" + code;
				}
				j = parent;
			}
			//存入std::map中方便查詢
			huffmanCode.insert(std::pair<K, std::string>(ht[i].data, code));
		}
	}
};

相關推薦

【資料結構與演算法基礎】哈夫曼樹與哈夫曼編碼(C++)

此文轉載自：https://blog.csdn.net/wayne_lee_lwc/article/details/109908756 前言 資料結構，一門資料處理的藝術，精巧的結構在一個又一個演算法下發揮著他們無與倫比的高效和精密之美，在為資訊科技打下堅實

哈夫曼樹與哈夫曼編碼

技術標籤：演算法與資料結構資料結構c++ 哈夫曼樹與哈夫曼編碼 哈夫曼樹如何構建哈夫曼樹構建哈夫曼樹的實現

10: java資料結構和演算法: 構建哈夫曼樹, 獲取哈夫曼編碼, 使用哈夫曼編碼原理對檔案壓縮和解壓

最終結果哈夫曼樹,如圖所示: 直接上程式碼: public class HuffmanCode { public static void main(String[] args) {

哈夫曼樹及哈夫曼編碼

哈夫曼樹及哈夫曼編碼 哈夫曼樹 基本介紹 給定n個葉子結點 ，構造一棵二叉樹。若該樹的帶權路徑長度（wpl）達到最值，則稱這棵樹為最有二叉樹，也稱為哈夫曼樹。

二叉樹之_哈夫曼樹_哈弗曼編碼

哈夫曼樹又稱最優二叉樹 給定N個權值作為N個葉子結點，構造一棵二叉樹，若該樹的帶權路徑長度達到最小，稱這樣的二叉樹為最優二叉樹，也稱為哈夫曼樹(Huffman Tree)。哈夫曼樹是帶權路徑長度最短的樹，權值

哈夫曼樹和哈夫曼編碼的java實現

哈夫曼 哈夫曼樹又稱最優二叉樹，是一種帶權路徑長度最短的二叉樹。所謂樹的帶權路徑長度，就是樹中所有的葉結點的權值乘上其到根結點的路徑長度（若根結點為0層，葉結點到根結點的路徑長度為葉結點的層數）。

哈夫曼樹和哈夫曼編碼

基礎概念 　哈夫曼樹又稱最優二叉樹，是一種帶權路徑長度最短的二叉樹。 結點的權值：

赫夫曼樹和赫夫曼編碼

赫夫曼樹 定義 給定n個權值作為n個葉子結點，構造一棵二叉樹，若該樹的帶權路徑長度(wpl)達到最小，稱這樣的二叉樹為最優二叉樹，也稱為哈夫曼樹(Huffman Tree), 還有的書翻譯為霍夫曼樹。

資料結構與演算法：哈夫曼樹

哈夫曼樹 給定N個權值作為N個葉子結點，構造一棵二叉樹，若該樹的帶權路徑長度達到最小，稱這樣的二叉樹為最優二叉樹，也稱為哈夫曼樹(Huffman Tree)。哈夫曼樹是帶權路徑長度最短的樹，權值較大的結點離根較近。

【C# 資料結構與演算法】哈夫曼樹

哈夫曼樹 定義 在含有n個帶權葉結點的二叉樹中，其中帶權路徑長度(WPL）最小的二叉樹稱為哈夫曼樹，也稱最優二叉樹 

哈夫曼樹(Huffman樹)原理分析及實現（C++）

1 構造原理   假設有n個權值，則構造出的哈夫曼樹有n個葉子結點。 n個權值分別設為 w1、w2、…、wn，則哈夫曼樹的構造規則為：

C++實現哈夫曼樹演算法

如何建立哈夫曼樹的，網上搜索一堆，這裡就不寫了，直接給程式碼。 1.哈夫曼樹結點類：HuffmanNode.h

C++實現哈夫曼樹編碼解碼

本文例項為大家分享了C++實現哈夫曼樹的編碼解碼，供大家參考，具體內容如下

C語言實現哈夫曼樹的構建

哈夫曼樹（霍夫曼樹）又稱為最優樹. 1、路徑和路徑長度 在一棵樹中，從一個結點往下可以達到的孩子或孫子結點之間的通路，稱為路徑。通路中分支的數目稱為路徑長度。若規定根結點的層數為1，則從根結點到第L層結點的

C語言實現哈夫曼樹

本文例項為大家分享了C語言實現哈夫曼樹的具體程式碼，供大家參考，具體內容如下

C++實現哈夫曼樹的方法

序言 對於哈夫曼編碼，個人的淺薄理解就是在壓縮儲存空間用很大用處。 用一個很簡單例子，儲存一篇英文文章時候，可能A出現的概率較大，Z出現的記錄較小，如果正常儲存，可能A與Z儲存使用的空間一樣。但是用哈夫曼編

哈夫曼樹學習筆記

定義 給定N個權值作為N個葉子結點，構造一棵二叉樹，若該樹的帶權路徑長度達到最小，稱這樣的二叉樹為最優二叉樹，也稱為哈夫曼樹(Huffman Tree)。哈夫曼樹是帶權路徑長度最短的樹，權值較大的結點離根較近。

資料結構—哈夫曼樹（Java）

資料結構—哈夫曼樹（Java） 部落格說明 文章所涉及的資料來自網際網路整理和個人總結，意在於個人學習和經驗彙總，如有什麼地方侵權，請聯絡本人刪除，謝謝！

Python描述資料結構學習之哈夫曼樹篇

前言 本篇章主要介紹哈夫曼樹及哈夫曼編碼，包括哈夫曼樹的一些基本概念、構造、程式碼實現以及哈夫曼編碼，並用Python實現。

哈夫曼樹

哈夫曼樹 簡介 哈夫曼樹（Huffman Tree），又名：最優二叉樹，赫夫曼樹 其標準含義是：給定N個權值作為N個葉子結點，構造一棵二叉樹，若該樹的帶權路徑長度達到最小，稱這樣的二叉樹為最優二叉樹，也稱為哈夫曼樹。哈