【无标题】

王卓《数据机构与算法》——哈夫曼树记录

#include <iostream>
#include <vector>
#include < cstring >
#include <string.h>
using namespace std;

//既可以用顺序存储结构，也可以用链式存储结构

//此处使用顺序存储结构——一维结构数组

//结点类型定义
typedef struct
{
	int weight;
	int parent, lch, rch;
}HTNode,*HuffmanTree;

//typedef char** Huffmancode;           //动态分配数组

/*
* 哈夫曼树中结点下标i |  weight  |  parent  |  lch  |  rch  |
* 1                 |          |          |       |       |
* 2                 |          |          |       |       |
* 3                 |          |          |       |       |
* .......           |          |          |       |       |
* 2n-1              |          |          |       |       |
*/

//n个数构成的哈夫曼树中共有n+n-1个结点
//为了简单操作，在使用一维数组HuffmanTree T对其进行保存时
//不使用0下标，数组大小为2n     1-2n

//找到HT中1-n范围内没有双亲结点且weight最小的两个结点的位置

void InitHTree(HuffmanTree &HT, const int n)
{
	//哈夫曼树的存储结构为顺序存储
	//由哈夫曼树的构造过程得知，n个权重结点构造出的哈夫曼树具有2*n-1个结点
	//通常哈夫曼树的顺序存储结构下标从1开始计数，因此，如果我们使用数组实现的话
	//那么数组的长度应该是2*n
	if (n < 1)
		return;

	HT = new HTNode[2 * n];
	for (int i = 1; i < 2 * n; ++i)
	{
		HT[i].parent = HT[i].lch = HT[i].rch = 0;//右结合律
	}
	int input;
	for (int i = 1; i <= n; ++i)
	{
		cin >> input;
		HT[i].weight = input;
	}
}

void Select1(HuffmanTree HT,const int n, int &s1, int &s2)
{
	int i;
	//s1存储最小
	for (i = 1; i <= n; i++)
	{
		if (HT[i].parent == 0)
		{
			s1 = i;
			break;
		}
	}

	//s2存储第二小
	for (i = s1 + 1; i <= n; i++)
	{
		if (HT[i].parent == 0)
		{
			s2 = i;
			break;
		}
	}

	if (HT[s2].weight < HT[s1].weight)
	{
		int temp;
		temp = s1;
		s1 = s2;
		s2 = temp;
	}


	for (i = s2 + 1; i <= n; i++)
	{
		if ((HT[i].weight < HT[s1].weight) && (HT[i].parent == 0))
		{
			s2 = s1;
			s1 = i;
		}

		if ((HT[i].weight >= HT[s1].weight) && (HT[i].weight < HT[s2].weight) && (HT[i].parent == 0))
		{
			s2 = i;
		}
	}
}

void Select(HuffmanTree &HT, const int n, int &s1, int &s2)
{
	vector<int> v;
	//存储双亲结点为0的结点的下标
	for (int i = 1; i <= n; i++)
	{
		if (HT[i].parent == 0)
		{
			v.push_back(i);
		}
	}

	//先找到weight最小的结点的下标存储到s1
	//it为指针
	auto flag1 = v.begin();
	for (auto it = v.begin(); it != v.end(); ++it)
	{
		if (HT[*it].weight < HT[*flag1].weight)
		{
			flag1 = it;
		}

	}

	s1 = *flag1;
	v.erase(flag1);

	//找到weight第二小的结点的下标存储到s2
	auto flag2 = v.begin();

	for (auto it = v.begin(); it != v.end(); ++it)
	{
		if (HT[*it].weight < HT[*flag2].weight)
		{
			flag2 = it;
		}

	}

	s2 = *flag2;
}


void CreateHuffmanTree(HuffmanTree &HT, const int n)  //构造哈夫曼树——哈夫曼算法
{
	//1.对哈夫曼树进行初始化
	InitHTree(HT, n);
	//初始化结束，下面开始建立哈夫曼树

	//3.进行以下n-1次合并，依次产生n-1个结点HT[i]，i=n+1........2n-1
	//a） 在HT[1...i-1]中选两个未被选过(从parent==0的结点中选)的weight
    //最小的两个结点HT[s1]和HT[s2]，s1、s2为两个最小结点下标
	int i;
	for (i = n + 1; i < 2*n; i++)   //合并产生n-1个结点——构造Huffman树
	{
		int s1=0, s2 = 0;
		Select(HT, i - 1, s1, s2);  //在HT[k](1<=k<=i-1)中选择两个其双亲域为0，且权值最小的结点，并返回他们在HT中的序号s1和s2
		HT[i].weight = HT[s1].weight + HT[s2].weight;
		HT[i].lch = s1;          //s1,s2分别作为i的左右孩子
		HT[i].rch = s2;
		HT[s1].parent = i;        //表示从F中删除s1,s2
		HT[s2].parent = i;
	}


}


void CreateHuffmanCode(HuffmanTree HT, char** &HC, int n)
{
	//从叶子到根逆向求每个字符的哈夫曼编码，存储在编码表HC中
	HC = new char*[n + 1];         //分配n个字符编码的头指针矢量  序号为叶子结点在哈夫曼树中的序号
	char* cd = new char[n];         //分配临时存放编码的动态数组空间   哈夫曼编码的长度不可能超过n-1   序号表示某一个叶子结点的哈夫曼编码的第几位
	cd[n - 1] = '\0';     //编码结束符
	int i;
	for (i = 1; i <= n; i++)    //逐个字符求哈夫曼编码
	{
		int start = n - 1;
		int c = i;
		int f = HT[i].parent;
		while (f != 0)   //从叶子结点开始向上回溯，直到根结点
		{
			--start;       //回溯一次start向前指一个位置
			if (HT[f].lch == c)    //结点是f的左孩子，则生成代码0
			{
				cd[start] = '0';          //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!注意这里的0是字符串常量，一开始写成0了，找了好久的错误
			}

			if (HT[f].rch == c)      //结点是f的右孩子，则生成代码1
			{
				cd[start] = '1';
			}
			c = f;
			f = HT[f].parent;
		}

		HC[i] = new char[n - start];   //包括结束符   为第i个字符串编码分配空间

		//for (int j = start; j <= n - 1; j++)
		//{
			//HC[i][j - start] = cd[j];
		//}
	
		strcpy(HC[i],&cd[start]);   //将求得的编码从临时空间复制到HC的当前行中
	}

	delete[] cd;      //释放临时空间

}


void PrintHT(HuffmanTree HT, int n)
{
	//system("cls");
	int m = 2 * n - 1;
	cout << "weight" << "\tparent" << "\tlch" << "\trch" << endl;
	for (int i = 1; i <= m; i++)
	{
		cout << HT[i].weight << "  \t" << HT[i].parent << "  \t" << HT[i].lch << "  \t" << HT[i].rch << "  \t" << endl;;
	}
}

void PrintHTCode(HuffmanTree HT, char** HC, int n)
{
	//system("cls");

	cout << "哈夫曼编码如下:" << endl;
	for (int i = 1; i <= n; i++)
	{
		cout << "频率为" << HT[i].weight << "的符号的哈夫曼编码为：" << HC[i] << endl;

		//for (int j = 0; HC[i][j]!='\0'; j++)
		//{
			//cout << HC[i][j];
		//}

	    //cout <<  endl;
	}
}

int main() {

	HuffmanTree HT;
	CreateHuffmanTree(HT,8);
	//PrintHT(HT, 8);

	char** HC;

	//HC是指针数组，每一个元素都是一个指针，指向一个字符数组，也就是说每一个元素都是一个字符数组的地址，所以也可以看成是一个二维的字符数组
	CreateHuffmanCode(HT, HC, 8);
	PrintHT(HT, 8);
	PrintHTCode(HT, HC, 8);

	system("pause");
	return 0;
}