漫谈C++哈夫曼树的原理及实现_C 语言

#include <iostream>
#include <queue>
#include <vector>
using namespace std;
//树结点
struct TreeNode {
	//结点权值
	float weight;
	//左结点
	TreeNode *lelfChild;
	//右结点
	TreeNode *rightChild;
    //初始化
	TreeNode(float w) {
		weight=w;
		lelfChild=NULL;
		rightChild=NULL;
    }
};
//为优先队列提供比较函数
struct comp {
	bool operator() (TreeNode * a, TreeNode * b) {
        //由大到小排列
		return a->weight > b->weight; 
	}
};

//哈夫曼树类
class HfmTree {
	private:
         //优先队列容器
		priority_queue<TreeNode *,vector<TreeNode *>,comp> hfmQueue;
	public:
		//构造函数，构建单根结点树
		HfmTree(int weights[8]) {
			for(int i=0; i<8; i++) {
				//创建不同权值的单根树
				TreeNode *tn=new TreeNode(weights[i]);
				hfmQueue.push(tn);
			}
		}
		//显示队列中的最一个结点
		TreeNode* showHfmRoot() {
			TreeNode *tn;
			while(!hfmQueue.empty()) {
				tn= hfmQueue.top();
				hfmQueue.pop();
			}
			return tn;
		}
		//构建哈夫曼树
		void create() {
             //重复直到队列中只有一个结点
			while(hfmQueue.size()!=1) {
				//从优先队列中找到权值最小的 2 个单根树
				TreeNode *minFirst=hfmQueue.top();
				hfmQueue.pop();
				TreeNode *minSecond=hfmQueue.top();
				hfmQueue.pop();
				//创建新的二叉树
				TreeNode *newRoot=new TreeNode(minFirst->weight+minSecond->weight);
				newRoot->lelfChild=minFirst;
				newRoot->rightChild=minSecond;
				//新二叉树放入队列中
				hfmQueue.push(newRoot);
			}
		}
		//按前序遍历哈夫曼树的所有结点
		void showHfmTree(TreeNode *root) {
			if(root!=NULL) {
				cout<<root->weight<<endl;
				showHfmTree(root->lelfChild);
				showHfmTree(root->rightChild);
			}
		}
		//析构函数
		~HfmTree() {
            //省略
		}
};

//测试
int main(int argc, char** argv) {
	//不同权值的结点
	int weights[8]= {3,6,12,9,4,8,21,22};
    //调用构造函数
	HfmTree hfmTree(weights);
    //创建哈夫曼树
	hfmTree.create();
    //前序方式显示哈夫曼树
	TreeNode *root= hfmTree.showHfmRoot();
	hfmTree.showHfmTree(root);
	return 0;
}

#include <iostream>
using namespace std;
//叶结点数量
const unsigned int n=8;
//一维数组长度
const unsigned int m= 2*n -1;
//树结点
struct TreeNode {
	//权值
	float weight;
	//父结点
	int parent;
	//左结点
	int leftChild;
	//右结点
	int rightChild;
};
class HuffmanTree {
	public:
		//创建一维数组
		TreeNode hfmNodes[m+1];
	public:
		//构造函数
		HuffmanTree(int weights[8]);
		~HuffmanTree( ) {

		}
		void findMinNode(int k, int &s1, int &s2);
		void showInfo() {
			for(int i=0; i<m; i++) {
				cout<<hfmNodes[i].weight<<endl;
			}
		}
};
HuffmanTree::HuffmanTree(int weights[8]) {
	//前2 个权值最小的结点
	int firstMin;
	int  secondMin;
	//初始化数组中的结点
	for(int i = 1; i <= m; i++) {
		hfmNodes[i].weight = 0;
		hfmNodes[i].parent = -1;
		hfmNodes[i].leftChild = -1;
		hfmNodes[i].rightChild = -1;
	}
	//前 n 个是叶结点
	for(int i = 1; i <= n; i++)
		hfmNodes[i].weight=weights[i-1];

	for(int i = n + 1; i <=m; i++) {
		this->findMinNode(i-1, firstMin, secondMin);
		hfmNodes[firstMin].parent = i;
		hfmNodes[secondMin].parent = i;
		hfmNodes[i].leftChild = firstMin;
		hfmNodes[i].rightChild = secondMin;
		hfmNodes[i].weight = hfmNodes[firstMin].weight + hfmNodes[secondMin].weight;
	}
}
void HuffmanTree::findMinNode(int k, int & firstMin, int & secondMin) {
	hfmNodes[0].weight = 32767;
	firstMin=secondMin=0;
	for(int i=1; i<=k; i++) {
		if(hfmNodes[i].weight!=0 && hfmNodes[i].parent==-1) {
			if(hfmNodes[i].weight < hfmNodes[firstMin].weight) { 
                  //如果有比第一小还要小的，则原来的第一小变成第二小
				secondMin = firstMin;
                  //新的第一小
				firstMin = i;
			} else if(hfmNodes[i].weight < hfmNodes[secondMin].weight)
			    //如果仅比第二小的小	
                 secondMin = i;
		}
	}
}

int main() {
	int weights[8]= {3,6,12,9,4,8,21,22};
	HuffmanTree huffmanTree(weights);
	huffmanTree.showInfo();
	return 1;
}