数据结构“二叉树操作的实现”与“基于哈夫曼树的数据压缩算法”的实验报告

一个不知名大学生，江湖人称菜狗
original author: jacky Li
Email : 3435673055@qq.com
Last edited: 2022.11.22

目录

二叉树操作的实现

一、实验项目

 二、实验目的

三、总体设计（设计原理、设计方案及流程等）

五、实验步骤（包括主要步骤、代码分析等）

代码

六、结果分析与总结

---

二叉树操作的实现

一、实验项目

利用二叉树的二叉链表的存储结构，编写一个程序完成对二叉树的操作的实现。

1. 根据输入的扩展二叉树的先序序列，构建二叉树的二叉链表存储结构；
2. 对二叉树进行中序遍历；
3. 求二叉树中结点的个数；
4. 求二叉树中叶子结点的个数；
5. 求二叉树中单孩子结点的个数；
6. 求二叉树的深度；
7. 将二叉树中所有结点的左右孩子进行交换。

 二、实验目的

通过该实验使学生对二叉树的特征、递归、指针、二叉树的二叉链表的存储及其操作的实现有更加深入的理解和认识，。

三、总体设计（设计原理、设计方案及流程等）

遍历二叉树 是指以一定的次序访问二叉树中的每个结点。所谓 访问结点 是指对结点进行各种操作的简称。例如，查询结点数据域的内容，或输出它的值，或找出结点位置，或是执行对结点的其他操作。遍历二叉树的过程实质是把二叉树的结点进行线性排列的过程。假设遍历二叉树时访问结点的操作就是输出结点数据域的值，那么遍历的结果得到一个线性序列。

五、实验步骤（包括主要步骤、代码分析等）

代码

#include <iostream>
#include <algorithm>
#include <map>
#include <vector>
#include <cmath>
#include <cstring>

#define IOS std::ios::sync_with_stdio(false)
//#define NO cout << "NO" << endl
//#define YES cout << "YES" << endl

using namespace std;
typedef long long LL;
typedef pair<LL, LL> PII;

typedef struct BiNode  //二叉链表定义
{				
	char data;
	struct BiNode *lchild,*rchild;
}BiTNode, *BiTree;

void CreateBiTree(BiTree &T) //按先序次序输入二叉树中结点的值（一个字符），创建二叉链表表示的二叉树T
{	
    char ch; cin >> ch;
    if(ch=='#') T = NULL;
    else
	{
        T = new BiTNode;
        T -> data = ch;
        CreateBiTree(T -> lchild);
        CreateBiTree(T -> rchild);
    }
}		

void InOrderTraverse(BiTree T)
{  
	//中序遍历二叉树T的递归算法
    if(T)
	{
        InOrderTraverse(T -> lchild);
        cout<< T -> data;
        InOrderTraverse(T -> rchild);
    }
}

int NodeCount(BiTree T) // 统计树中结点个数 
{
    if(T == NULL) return 0;
    else return NodeCount(T -> lchild) + NodeCount(T -> rchild) + 1;
} 

int Depth(BiTree T) // 求二叉树深度 
{ 
    if(T == NULL) return 0;
    else
	{
        int m = Depth(T -> lchild);
        int n = Depth(T -> rchild);
        if(m > n) return (m + 1);
        else return (n + 1);
    }
}

int LeafNode(BiTree T) // 求叶子节点个数 
{
    int count = 0;
    
    if(T == NULL) return 0;
    else if(T -> lchild == NULL && T -> rchild == NULL) return count + 1;
    else 
    {
        count = LeafNode(T -> lchild) + LeafNode(T -> rchild);
        return count;
    }
} 

int lonly_LeafNode(BiTree T)
{
	if(T == NULL) return 0;
	else if((T -> lchild == NULL && T -> rchild != NULL) || (T -> lchild != NULL && T -> rchild == NULL))
		return 1 + lonly_LeafNode(T -> lchild) + lonly_LeafNode(T -> rchild);
	return lonly_LeafNode(T -> lchild) + lonly_LeafNode(T -> rchild);
} 

void ChangeLR(BiTree &T) // 交换左右子树 
{
	BiTNode *temp = NULL;
	if(!T) return;
    else 
    {
		temp = T -> lchild;
		T -> lchild = T -> rchild;
		T -> rchild = temp;
    }
    ChangeLR(T -> lchild);
	ChangeLR(T -> rchild);
} 

signed main()
{
	BiTree tree;
	CreateBiTree(tree);
	InOrderTraverse(tree);
	cout << "节点个数" << NodeCount(tree) << endl;
	cout << "叶子节点个数" << LeafNode(tree) << endl;
	cout << "单孩子节点个数" << lonly_LeafNode(tree) << endl;
	cout << "树的深度" << Depth(tree) << endl;
	ChangeLR(tree);
	InOrderTraverse(tree);
} 

六、结果分析与总结

分析自己看着写吧 

数据结构“基于哈夫曼树的数据压缩算法”的实验报告

课程名称：	数据结构
项目名称：	基于哈夫曼树的数据压缩算法
实验类型：	验证性实验

一、实验目的

1）初始化（Initialzation）。 输入字符个数、字符及字符对应的权值，建立哈夫曼树（HuffmanTree） 。

2）根据哈夫曼树，求各字符的哈夫曼编码输出 。

3）编码（EnCoding）。利用哈夫曼编码对输入的字符串进行译码形成报文（0、1代码）并输出；

4）译码（Decoding）。利用已建好的哈夫曼树，对输入的报文（0、1代码）进行解码形成原文并输出；
二、实验设备

装有Dev C++的计算机一台

三、实验内容

结合在头歌上已完成的实训任务进行填写

1.【问题描述】

输入一串字符串，根据给定的字符串中字符出现的频率建立相应的哈夫曼树，构造哈夫曼编码表，在此基础上可以对压缩文件进行压缩（即编码），同时可以对压缩后的二进制编码文件进行解压（即译码）。

2.【输入要求】

多组数据，每组数据1行，为一个字符串（只考虑26个小写字母即可）。当输入字符串为“0”时，输入结束。

3.【输出要求】

每组数据输出2n+3行（n为输入串中字符类别的个数）。第1行为统计出来的字符出现频率（只输出存在的字符，格式为：字符：频度），每两组字符之间用一个空格分隔，字符按照ASCII码从小到大的顺序排列。第2行至第2n行为哈夫曼树的存储结构的终态（如主教材139页表5.2（b），一行当中的数据用空格分隔）。第2n+1行为每个字符的哈夫曼编码（只输出存在的字符，格式为：字符：编码），每两组字符之间用一个空格分隔，字符按照ASCII码从小到大的顺序排列。第2n+2行为编码后的字符串，第2n+3行为解码后的字符串（与输入的字符串相同）。

4.【实验提示】

此实验内容即要求实现主教材的案例5.1，具体实现可参考算法5.10和算法5.11。首先，读入一行字符串，统计每个字符出现的频率；然后，根据字符出现的频率利用算法5.10建立相应的哈夫曼树；最后，根据得到的哈夫曼树利用算法5.11求出每个字符的哈夫曼编码。

四、实验步骤

4.1

此部分可包含解题思路、最初填写的但没有通过的程序，通过调试如何找到问题并做出改正，可粘贴调整规范的截图

4.2编程和调试

此部分可包含解题思路、最初填写的但没有通过的程序，通过调试如何找到问题并做出改正，可粘贴调整规范的截图

五、实验结果

5.1程序完成后关键源码及运行结果截图

可以将最终完成的代码及运行结果在此展示。

六、实验总结

用简介、准确的语言描述本次实验重点解决了什么问题，学习了什么知识，自己掌握的如何等等

七、划重点参考代码

#include <iostream>
#include <algorithm>
#include <map>
#include <cmath>
#include <cstring>

#define IOS std::ios::sync_with_stdio(false)

using namespace std;

typedef struct
{
	int weight;
	int parent, lchild, rchild;
}HTNode, *HuffmanTree;

typedef char **HuffmanCode;

char ch[10];

void Select(HuffmanTree HT,int len,int &s1,int &s2)
{
    int i, min1 = 0x3f3f3f3f, min2 = 0x3f3f3f3f;
    
    for(i = 1; i <= len; i ++)
    	if(HT[i].parent == 0 && min1 > HT[i].weight)
    		min1 = HT[i].weight, s1 = i;
    		
    for(i = 1; i <= len; i ++)
    	if(i != s1 && HT[i].parent == 0)
    		if(HT[i].weight < min2)
        		min2 = HT[i].weight, s2 = i;
}
 
void CreatHuffmanTree(HuffmanTree &HT, int n, int s[])
{
    if(n <= 1) return;
    int m = 2 * n - 1;
    HT = new HTNode[m + 1];
    for(int i = 1; i <= m; i ++)
        HT[i].parent = 0, HT[i].lchild = 0, HT[i].rchild = 0;
        
    for(int i = 1; i <= 26; i ++) 
		if(s[i] != 0) 
			HT[i].weight = s[i];
    
    for(int i = n + 1; i <= m; i ++)
	{
        int s1, s2;
        Select(HT, i - 1, s1, s2);
        HT[s1].parent = i;
		HT[s2].parent = i;
        HT[i].lchild = s1;
        HT[i].rchild = s2;
        HT[i].weight = HT[s1].weight + HT[s2].weight;
    }
}
 
void CreatHuffmanCode(HuffmanTree HT, HuffmanCode &HC, int n)
{
	char *cd;
    HC = new char*[n + 1], cd = new char[n];
    
    cd[n - 1] = '\0';
    for(int i = 1; i <= n; i ++)
	{
        int start = n - 1;
        int c = i, f = HT[i].parent;
        while(f != 0)
		{
            -- start;
            if(HT[f].lchild == c) cd[start] = '0';
            else cd[start] = '1';
            c = f, f = HT[f].parent;
        }
        HC[i] = new char[n - start];
        strcpy(HC[i], &cd[start]);
    }
    delete cd;
}

void show(HuffmanCode HC, int h)
{
	for(int i = 1; i <= h; i ++)
		cout << HC[i] << endl;
}

void init()
{
	IOS;
	for(int i = 0; ; i ++)
	{
		char a; cin >> a;
		if(a != '0') ch[i] = a;
		else break;
	}
}

int main()
{
	IOS; init();
	int s[27], t = strlen(ch), h = 0;
	memset(s, 0, sizeof s);
	
	for(int i = 0; i <= t; i ++) s[ch[i] - 'a' + 1] ++;
	
	for(int i = 0; i <= 26; i ++)
		if(s[i] != 0) h ++;
	cout << h << endl;
	
	for(int i = 1; i <= 26; i ++)
		if(s[i] != 0)
			cout << (char)(i + 'a' - 1) << ":" << s[i] << ' ';
	cout << endl;
	
	
	HuffmanTree HT;
	HuffmanCode HC;

	CreatHuffmanTree(HT, h, s);
	CreatHuffmanCode(HT, HC, h);
	show(HC, h);
 
    return 0;
}