A. DS二叉树--赫夫曼树的构建与编码
题目描述
给定n个权值，根据这些权值构造huffman树，并进行huffman编码
大家参考课本算法6.12为主，注意数组访问是从位置1开始
要求：赫夫曼的构建中，默认左孩子权值不大于右孩子权值
输入
第一行先输入n，表示有n个权值，即有n个叶子
第二行输入n个权值，权值全是小于1万的正整数
输出
逐行输出每个权值对应的编码，格式如下：权值-编码
即每行先输出1个权值，再输出一个短划线，再输出对应编码
接着下一行输出下一个权值和编码，以此类推
样例查看模式
正常显示查看格式
输入样例1
5
15 4 4 3 2
输出样例1
15-1
4-010
4-011
3-001
2-000
AC代码
#include<iostream>
using namespace std;
struct Hatnode
{
int parent, left, right, weight;
string code;
int data;
Hatnode()
{
parent = 0;
left = 0;
right = 0;
}
};
class Hatree
{
Hatnode* root;
int num;
public:
Hatree(int n = 0)
{
num = n;
root = new Hatnode[2 * n];
for (int i = 1; i <= n; i++)
{
root[i].data = i;
cin >> root[i].weight;
}
}
void selectMin(int len, int& p1, int& p2)
{
int min1, min2;
min1 = min2 = 10000;
p1 = p2 = 0;
for (int i = 1; i < len; i++)
{
if (root[i].parent == 0)
{
if (root[i].weight < min1)
{
min2 = min1;
p2 = p1;
min1 = root[i].weight;
p1 = i;
}
else if (root[i].weight < min2)
{
min2 = root[i].weight;
p2 = i;
}
}
}
}
void createtree()
{
int p1 = 0, p2 = 0;
for (int i = num + 1; i < 2 * num; i++)
{
selectMin(i, p1, p2);
root[i].left = p1;
root[i].right = p2;
root[p1].parent = root[p2].parent = i;
root[i].weight = root[p1].weight + root[p2].weight;
}
}
void hacode()
{
for (int i = 1; i <= num; i++)
{
for (int c = i, f = root[i].parent; f != 0; c = f, f = root[f].parent)
{
if (root[f].left == c)
{
(root + i)->code = '0' + (root + i)->code;
}
else
{
(root + i)->code = '1' + (root + i)->code;
}
}
}
}
void Code()
{
for (int i = 1; i <= num; i++)
{
cout << (root + i)->weight << "-" << (root + i)->code << endl;
}
}
};
int main()
{
int n;
cin >> n;
Hatree tree(n);
tree.createtree();
tree.hacode();
tree.Code();
return 0;
}B. DS二叉树--赫夫曼树解码
题目描述
已知赫夫曼编码算法和程序，在此基础上进行赫夫曼解码
可以增加一个函数：int Decode(const string codestr, char txtstr[]);//输入编码串codestr，输出解码串txtstr
该方法如果解码成功则返回1，解码失败则返回-1，本程序增加宏定义ok表示1，error表示-1
赫夫曼解码算法如下：
定义指针p指向赫夫曼树结点，指针i指向编码串，定义ch逐个读取编码串的字符
初始操作包括读入编码串str，设置p指向根结点，i为0表示指向串首，执行以下循环：
1）取编码串的第i个字符放入ch
2）如果ch是字符0，则p跳转到左孩子；如果ch是字符1，则p跳转到右孩子；如果ch非0非1，表示编码串有错误，报错退出
3）如果p指的结点是叶子，输出解码字符，p跳回根结点，i++，跳步骤1
4）如果p指的结点不是叶子且i未到编码串末尾，i++，跳步骤1
5）如果p指的结点不是叶子且i到达编码串末尾，报错退出
当i到达编码串末尾，解码结束。
输入
第一行先输入n，表示有n个叶子
第二行输入n个权值，权值全是小于1万的正整数
第三行输入n个字母，表示与权值对应的字符
第四行输入k，表示要输入k个编码串
第五行起输入k个编码串
输出
每行输出解码后的字符串，如果解码失败直接输出字符串“error”，不要输出部分解码结果
样例查看模式
正常显示查看格式
输入样例1
5
15 4 4 3 2
A B C D E
3
11111
10100001001
00000101100
输出样例1
AAAAA
ABEAD
error
AC代码
#include<iostream>
using namespace std;
struct Hatnode
{
int parent, left, right, weight;
string code;
char data;
Hatnode()
{
parent = 0;
left = 0;
right = 0;
}
};
class Hatree
{
Hatnode* root;
int num;
public:
Hatree(int n = 0)
{
num = n;
root = new Hatnode[2 * n];
for (int i = 1; i <= n; i++)
{
cin >> root[i].weight;
}
for (int i = 1; i <= n; i++)
{
cin >> root[i].data;
}
}
void selectMin(int len, int& p1, int& p2)
{
int min1, min2;
min1 = min2 = 10000;
p1 = p2 = 0;
for (int i = 1; i < len; i++)
{
if (root[i].parent == 0)
{
if (root[i].weight < min1)
{
min2 = min1;
p2 = p1;
min1 = root[i].weight;
p1 = i;
}
else if (root[i].weight < min2)
{
min2 = root[i].weight;
p2 = i;
}
}
}
}
void createtree()
{
int p1 = 0, p2 = 0;
for (int i = num + 1; i < 2 * num; i++)
{
selectMin(i, p1, p2);
root[i].left = p1;
root[i].right = p2;
root[p1].parent = root[p2].parent = i;
root[i].weight = root[p1].weight + root[p2].weight;
}
}
void hacode()
{
for (int i = 1; i <= num; i++)
{
for (int c = i, f = root[i].parent; f != 0; c = f, f = root[f].parent)
{
if (root[f].left == c)
{
(root + i)->code = '0' + (root + i)->code;
}
else
{
(root + i)->code = '1' + (root + i)->code;
}
}
}
}
int Decode(const string s, string& ans)
{
int ed = 2 * num - 1;
int st = ed;
bool flag = 1;
for (int i = 0; i < s.size(); i++)
{
if (s[i] == '0')
{
st = root[st].left;
}
else if (s[i] == '1')
{
st = root[st].right;
}
else
{
return -1;
}
if (root[st].left == 0 && root[st].right == 0)
{
ans += root[st].data;
st = ed;
flag = 1;
}
else
{
flag = 0;
}
}
if (!flag)
{
return-1;
}
return 1;
}
};
int main()
{
int n;
cin >> n;
Hatree tree(n);
tree.createtree();
tree.hacode();
cin >> n;
while (n--)
{
string s;
cin >> s;
string res;
if (tree.Decode(s, res) == -1)
{
cout << "error" << endl;
}
else
{
cout << res << endl;
}
}
return 0;
}C. DS树--带权路径和
题目描述
二叉树的创建使用含空树表示的先序遍历序列，计算一棵二叉树的带权路径总和，即求赫夫曼树的带权路径和。
已知一棵二叉树的叶子权值，该二叉树的带权路径和WPL等于叶子权值乘于根节点到叶子的分支数，然后求总和。
如下图中，叶子都用大写字母表示，权值对应为：A-7，B-6，C-2，D-3
树的带权路径和 = 7*1 + 6*2 + 2*3 + 3*3 = 34
输入
第一行输入一个整数t，表示有t个二叉树
第二行输入一棵二叉树的先序遍历结果，空树用字符‘0’表示，注意输入全是英文字母和0，其中大写字母表示叶子
第三行先输入n表示有n个叶子，接着输入n个数据表示n个叶子的权值，权值的顺序和前面输入的大写字母顺序对应
以此类推输入下一棵二叉树
输出
输出每一棵二叉树的带权路径和
样例查看模式
正常显示查看格式
输入样例1
2
xA00tB00zC00D00
4 7 6 2 3
ab0C00D00
2 10 20
输出样例1
34
40
AC代码
#include<iostream>
#include<queue>
#include<stack>
using namespace std;
struct node
{
node* l;
node* r;
char data;
int weight;//权重
int depth;//记录层数
node(char d, node* ll = NULL, node* rr = NULL)
{
data = d;
l = ll;
r = rr;
}
};
class tree
{
node* root;
//再建树中赋值层数
void Create(node*& n,int dep=0)
{
char ch;
cin >> ch;
if (ch == '0')
{
n = NULL;
return;
}
n = new node(ch);
n->depth = dep;
Create(n->l,dep+1);
Create(n->r,dep+1);//加一操作
}
void inweight(node* n)
{
if (!n)return;
//只有叶子有权值
if (!n->l && !n->r)
{
cin >> n->weight;
}
inweight(n->l);
inweight(n->r);
}
void Delete(node* n)
{
if (!n)
{
delete n;
return;
}
Delete(n->l);
Delete(n->r);
delete n;
}
void Pre(node* n)
{
if (!n)return;
cout << n->data;
Pre(n->l);
Pre(n->r);
}
void Mid(node* n)
{
if (!n)return;
Mid(n->l);
cout << n->data;
Mid(n->r);
}
void Pos(node* n)
{
if (!n)return;
Pos(n->l);
Pos(n->r);
cout << n->data;
}
void Child(node* n)
{
if (!n)return;
if (!n->l && !n->r)
{
cout << n->data << " ";
}
Child(n->l);
Child(n->r);
}
void Fath(node* n)
{
if (!n)return;
Fath(n->l);
Fath(n->r);
if (n->l && !(n->l->l) && !(n->l->r))
{
cout << n->data << " ";
}
if (n->r && !(n->r->l) && !(n->r->r))
{
cout << n->data << " ";
}
}
int high(node* n)
{
if (!n)return 0;
int lefth = high(n->l);
int righth = high(n->r);
return max(lefth, righth) + 1;
}
public:
tree()
{
root = NULL;
}
void createtree()
{
Create(root);
}
~tree()
{
Delete(root);
}
void preorder()
{
Pre(root);
cout << endl;
}
void midorder()
{
Mid(root);
cout << endl;
}
void posorder()
{
Pos(root);
cout << endl;
}
void child()
{
Child(root);
cout << endl;
}
void father()
{
Fath(root);
cout << endl;
}
void lerorder()
{
queue<node*>q;
q.push(root);
while (!q.empty())
{
auto t = q.front();
q.pop();
if (!t)continue;
cout << t->data;
q.push(t->l);
q.push(t->r);
}
cout << endl;
}
void gethigh()
{
cout << high(root) << endl;
}
void input_weight()
{
int n;
cin >> n;
inweight(root);
}
//计算带权路径和
int count_path()
{
//使用栈计算
int ans = 0;
stack<node*>s;//s存结点
s.push(root);
while (!s.empty())
{
node* cur = s.top();
s.pop();
if (!cur)continue;
s.push(cur->l);
s.push(cur->r);
//到叶子了
if (!cur->l && !cur->r)
{
ans += cur->depth * cur->weight;
}
}
return ans;
}
};
int main()
{
int t;
cin >> t;
while (t--)
{
tree tt;
tt.createtree();
tt.input_weight();
cout << tt.count_path() << endl;
}
return 0;
}D. DS树--二叉树之最大路径
题目描述
给定一颗二叉树的逻辑结构（先序遍历的结果，空树用字符‘0’表示，例如AB0C00D00），建立该二叉树的二叉链式存储结构
二叉树的每个结点都有一个权值，从根结点到每个叶子结点将形成一条路径，每条路径的权值等于路径上所有结点的权值和。编程求出二叉树的最大路径权值。如下图所示，共有4个叶子即有4条路径，
路径1权值=5 + 4 + 11 + 7 = 27路径2权值=5 + 4 + 11 + 2 = 22
路径3权值=5 + 8 + 13 = 26路径4权值=5 + 8 + 4 + 1 = 18
可计算出最大路径权值是27。
该树输入的先序遍历结果为ABCD00E000FG00H0I00，各结点权值为：
A-5，B-4，C-11，D-7，E-2，F-8，G-13，H-4，I-1
输入
第一行输入一个整数t，表示有t个测试数据
第二行输入一棵二叉树的先序遍历，每个结点用字母表示
第三行先输入n表示二叉树的结点数量，然后输入每个结点的权值，权值顺序与前面结点输入顺序对应
以此类推输入下一棵二叉树
输出
每行输出每棵二叉树的最大路径权值，如果最大路径权值有重复，只输出1个
样例查看模式
正常显示
输入样例1
AB0C00D00
4 5 3 2 6
ABCD00E000FG00H0I00
9 5 4 11 7 2 8 13 4 1
4 5 3 2 6
ABCD00E000FG00H0I00
9 5 4 11 7 2 8 13 4 1
输出样例1
11
27
27
AC代码
#include<iostream>
#include<queue>
#include<stack>
using namespace std;
struct node
{
node* l;
node* r;
char data;
int weight;//权重
int depth;//记录层数
node(char d, node* ll = NULL, node* rr = NULL)
{
data = d;
l = ll;
r = rr;
}
};
class tree
{
node* root;
//再建树中赋值层数
void Create(node*& n,int dep=0)
{
char ch;
cin >> ch;
if (ch == '0')
{
n = NULL;
return;
}
n = new node(ch);
n->depth = dep;
Create(n->l,dep+1);
Create(n->r,dep+1);//加一操作
}
void inweight(node* n)
{
if (!n)return;
//只要是结点都有权值
cin >> n->weight;
inweight(n->l);
inweight(n->r);
}
void Delete(node* n)
{
if (!n)
{
delete n;
return;
}
Delete(n->l);
Delete(n->r);
delete n;
}
void Pre(node* n)
{
if (!n)return;
cout << n->data;
Pre(n->l);
Pre(n->r);
}
void Mid(node* n)
{
if (!n)return;
Mid(n->l);
cout << n->data;
Mid(n->r);
}
void Pos(node* n)
{
if (!n)return;
Pos(n->l);
Pos(n->r);
cout << n->data;
}
void Child(node* n)
{
if (!n)return;
if (!n->l && !n->r)
{
cout << n->data << " ";
}
Child(n->l);
Child(n->r);
}
void Fath(node* n)
{
if (!n)return;
Fath(n->l);
Fath(n->r);
if (n->l && !(n->l->l) && !(n->l->r))
{
cout << n->data << " ";
}
if (n->r && !(n->r->l) && !(n->r->r))
{
cout << n->data << " ";
}
}
int high(node* n)
{
if (!n)return 0;
int lefth = high(n->l);
int righth = high(n->r);
return max(lefth, righth) + 1;
}
//最大路径为根节点到叶子的一条路径，路径的权值等于路径上所有结点的权值和
int maxpath(node* n)
{
if (!n)return 0;
int left_maxpath = maxpath(n->l);
int right_maxpath = maxpath(n->r);
return n->weight + max(left_maxpath, right_maxpath);
}
public:
tree()
{
root = NULL;
}
void createtree()
{
Create(root);
}
~tree()
{
Delete(root);
}
void preorder()
{
Pre(root);
cout << endl;
}
void midorder()
{
Mid(root);
cout << endl;
}
void posorder()
{
Pos(root);
cout << endl;
}
void child()
{
Child(root);
cout << endl;
}
void father()
{
Fath(root);
cout << endl;
}
void lerorder()
{
queue<node*>q;
q.push(root);
while (!q.empty())
{
auto t = q.front();
q.pop();
if (!t)continue;
cout << t->data;
q.push(t->l);
q.push(t->r);
}
cout << endl;
}
void gethigh()
{
cout << high(root) << endl;
}
void input_weight()
{
int n;
cin >> n;
inweight(root);
}
//计算带权路径和
int count_path()
{
//使用栈计算
int ans = 0;
stack<node*>s;//s存结点
s.push(root);
while (!s.empty())
{
node* cur = s.top();
s.pop();
if (!cur)continue;
s.push(cur->l);
s.push(cur->r);
//到叶子了
if (!cur->l && !cur->r)
{
ans += cur->depth * cur->weight;
}
}
return ans;
}
int max_path()
{
return maxpath(root);
}
};
int main()
{
int t;
cin >> t;
while (t--)
{
tree tt;
tt.createtree();
tt.input_weight();
cout << tt.max_path() << endl;
}
return 0;
}E. DS二叉树—二叉树镜面反转
题目描述
假设二叉树用二叉链表存储，用含空子树遍历的先序序列结果创建。空子树用字符#表示
输入二叉树的先序序列，请你先创建二叉树，并对树做个镜面反转，再输出反转后的二叉树的先序遍历、中序遍历、后序遍历和层序遍历的序列。所谓镜面反转，是指将所有非叶结点的左右孩子对换。
--程序要求--
程序中不允许使用STL库等第三方对象或函数实现本题的要求
输入
测试次数t
每组测试数据是一个二叉树的先序遍历序列，#表示空树
输出
对每棵二叉树，输出镜面反转后的先序、中序、后序和层次遍历序列。如果空树，输出四个NULL（后面不加空格，每个NULL独自一行，中间没有空行）。如下：
NULL
NULL
NULL
NULL
样例查看模式
正常显示查看格式
输入样例1
3
41#32###65##7##
AB#C##D##
AB##C##
输出样例1
4 6 7 5 1 3 2
7 6 5 4 3 2 1
7 5 6 2 3 1 4
4 6 1 7 5 3 2
A D B C
D A C B
D C B A
A D B C
A C B
C A B
C B A
A C B
AC代码
#include<iostream>
#include<queue>
#include<stack>
using namespace std;
struct node
{
node* l;
node* r;
char data;
node(char d, node* ll = NULL, node* rr = NULL)
{
data = d;
l = ll;
r = rr;
}
};
class tree
{
node* root;
void Create(node*& n)
{
char ch;
cin >> ch;
if (ch == '#')
{
n = NULL;
return;
}
n = new node(ch);
//只需修改这里，交换左右孩子即可
Create(n->r);
Create(n->l);
}
void Delete(node* n)
{
if (!n)
{
delete n;
return;
}
Delete(n->l);
Delete(n->r);
delete n;
}
void Pre(node* n)
{
if (!n)return;
cout << n->data<<" ";
Pre(n->l);
Pre(n->r);
}
void Mid(node* n)
{
if (!n)return;
Mid(n->l);
cout << n->data<<" ";
Mid(n->r);
}
void Pos(node* n)
{
if (!n)return;
Pos(n->l);
Pos(n->r);
cout << n->data<<" ";
}
void Child(node* n)
{
if (!n)return;
if (!n->l && !n->r)
{
cout << n->data << " ";
}
Child(n->l);
Child(n->r);
}
void Fath(node* n)
{
if (!n)return;
Fath(n->l);
Fath(n->r);
if (n->l && !(n->l->l) && !(n->l->r))
{
cout << n->data << " ";
}
if (n->r && !(n->r->l) && !(n->r->r))
{
cout << n->data << " ";
}
}
int high(node* n)
{
if (!n)return 0;
int lefth = high(n->l);
int righth = high(n->r);
return max(lefth, righth) + 1;
}
public:
tree()
{
root = NULL;
}
void createtree()
{
Create(root);
}
~tree()
{
Delete(root);
}
void preorder()
{
Pre(root);
cout << endl;
}
void midorder()
{
Mid(root);
cout << endl;
}
void posorder()
{
Pos(root);
cout << endl;
}
void child()
{
Child(root);
cout << endl;
}
void father()
{
Fath(root);
cout << endl;
}
void lerorder()
{
queue<node*>q;
q.push(root);
while (!q.empty())
{
auto t = q.front();
q.pop();
if (!t)continue;
cout << t->data<<" ";
q.push(t->l);
q.push(t->r);
}
cout << endl;
}
void gethigh()
{
cout << high(root) << endl;
}
};
int main()
{
int t;
cin >> t;
while (t--)
{
tree tt;
tt.createtree();
tt.preorder();
tt.midorder();
tt.posorder();
tt.lerorder();
}
return 0;
}
