南邮哈夫曼编码和译码系统

element = x；
lChild = l;
rChild = r;
｝
}；
实 验 报 告
template〈class T〉
class BinaryTree｛
public：
BinaryTree（)｛
root = NULL；
｝
～BinaryTree（）{}
bool isEmpty（) const｛
return root == NULL;
bool IsEmpty() const｛return n==0；}
bool IsFull() const｛return n==maxSize；}
void Append(const T &x）;
void Serve(T＆x)；
private:
void AdjustDown（int r, int j）;
void AdjustUp (int j）；
T* q；
int n,maxSize;
｝；
template <class T>
PrioQueue<T>：:PrioQueue（int mSize）｛
maxSize=mSize;
n=0；
实 验 报 告
q=new T[maxSize]；
}
template〈class T〉
if (t）｛
postClear（t —> lChild）;
postClear（t —> rChild);
delete t；
}
｝
实 验 报 告
template <class T>
BTNode<T>* BinaryTree〈T>：：copy(BTNode〈T〉*t)｛
if（!t）return NULL；
BTNode<T〉＊lChild, *rChild;
BTNode（）｛
lChild = rChild = NULL;
}
BTNode（const T& x）{
element = x;
lChild = rChild = NULL；
｝
BTNode（const T& x，BTNode〈T〉* l, BTNode〈T〉＊r)｛
visit（t —〉element）；
inOrder(t —> rChild）;
｝
｝
template <class T〉
void BinaryTree<T>:：postOrder(BTNode<T〉* t）｛
if (t）｛
postOrder（t -> lChild);
postOrder（t -> rChild）；
#include〈iostream〉
＃include <queue〉
#include〈string>
using namespace std；
int *weightArray；
string s；
string＊codeArray；
template <class T>
struct BTNode｛
T element;
if（！t) return 0；
else return size(t —> lChild) + size（t -〉rChild)；
}
template〈class T〉
void BinaryTree〈T>::change（BTNode<T〉＊t)｛
if（!t）return;
BTNode<T〉*q = copy(t —> rChild);
cout <〈x〈〈” "；
｝
}；
template〈class T>
bool BinaryTree<T>:：retRoot(T& x) const｛
if（root) {
x = root -〉element;
return true;
｝else return false；
}
template <class T〉
实验题二：哈夫曼编码和译码系统
（1)所设计的系统重复显示以下菜单项：
B―――建树：读入字符集和各字符频度,建立哈夫曼树.
T―――遍历：先序和中序遍历二叉树。
E―――生成编码:根据已建成的哈夫曼树，产生各字符的哈夫曼编码。
C―――编码：输入由字符集中字符组成的任意字符串，利用已生成的哈夫曼编码进行编码,显示编码结果，并将输入的字符串及其编码结果分别保存在磁盘文件textfile.txt和codefile.txt中。
BTNode<T>＊q = new BTNode<T>(t -〉element)；
q -〉lChild = copy（t —> lChild);
q —〉rChild = copy(t —> rChild）；
return q;
｝
template <class T〉
int BinaryTree〈T〉:：size（BTNode<T〉* t）｛
int height(BTNode〈T>＊t）；
void preOrder(BTNode<T>＊t）;
void inOrder(BTNode〈T〉＊t）;
void postOrder(BTNode〈T>＊t)；
void breathFirst(BTNode<T>＊t);
void visit(T＆x) {
}
x=q［0］；q[0］=q［——n]；
AdjustDown (0，n-1）；
｝
template <class T>
void PrioQueue<T>：:AdjustDown（int r, int j) {
int child = 2 * r + 1;
T temp = q［r］;
while (child <= j）{
void PrioQueue〈T〉::AdjustUp (int j)｛
int i=j;T temp=q[i］;
while（i〉0＆& temp〈q［(i—1)/2］）{
q［i]=q［（i—1）/2]；
i=(i-1)/2;
｝
q［i]=temp；
｝
template <class T>
void PrioQueue<T〉：:Append(const T＆x）
left.root = right.root = NULL;
｝
template <class T〉
void BinaryTree<T>:：breakTree(T& x，BinaryTree<T>& left，BinaryTree〈T〉& right) {
if (！root｜｜＆left ==＆right｜｜left.root｜| right。root) return;
BTNode〈T〉* root;
private：
void clear（BTNode<T〉* t);
void change（BTNode<T>* t）;
void postClear(BTNode<T〉＊t）；
void prePrint（BTNode<T>* t）；
int size（BTNode〈T〉＊t）；
visit（t —> element）；
return;
｝
prePrint(t —〉lChild）；
prePrint(t —> rChild）;
｝
}
template〈class T〉
class PrioQueue {
public：
PrioQueue（int mSize=20）;
~PrioQueue（）｛delete[] q;}；
}
void change（) {
change(root）;
｝
void breathFirst（) {
breathFirst(root);
｝
int height（) {
return height(root)；
｝
void leaf() {
prePrint（root）；
}
实 验 报 告
protected:
if（t）｛
visit（t —〉element）；
preOrder（t -〉lChild）;
preOrder（t —> rChild);
}
}
template <class T〉
void BinaryTree<T>：:inOrder（BTNode<T〉＊t）{
if (t）{
inOrder(t -〉lChild);
｛
if（IsFull（）) {
cout<〈"Overflow”；
urn；
}
q[n++]=x；
AdjustUp（n-1）;
｝
template〈class T>
void PrioQueue〈T〉:：Serve(T＆x）
{
if(IsEmpty()）｛
cout〈〈”Underflow”;
return;
visit（t —> element)；
｝
｝
template〈class T〉
void BinaryTree<T>：:clear(BTNode〈T>＊t)｛