数据结构二叉树遍历实验报告
二叉树的遍历实验报告
二叉树的遍历实验报告二叉树的遍历实验报告引言：二叉树是一种常见的数据结构，它由节点和连接节点的边组成。
在实际应用中，我们经常需要对二叉树进行遍历，以便对其中的节点进行访问和操作。
本次实验旨在探索二叉树的遍历算法，并通过实验验证其正确性和效率。
一、二叉树的定义和基本操作二叉树是一种特殊的树结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。
根据节点的访问顺序，二叉树的遍历可以分为前序遍历、中序遍历和后序遍历三种方式。
前序遍历是指先访问根节点，然后按照左子树、右子树的顺序递归地进行遍历；中序遍历是指先按照左子树、根节点、右子树的顺序递归地进行遍历；后序遍历是指先按照左子树、右子树、根节点的顺序递归地进行遍历。
二、实验设计和方法为了验证二叉树的遍历算法的正确性和效率，我们设计了以下实验方案：1. 构建二叉树：我们首先构建一个具有一定规模的二叉树，以模拟实际应用中的情况。
为了方便起见，我们选择随机生成一棵二叉树，并确保其结构合理。
2. 实现遍历算法：我们根据前文所述的遍历方式，实现了相应的遍历算法。
在实现过程中，我们考虑到了递归和迭代两种方式，并分别进行了实验比较。
3. 遍历实验：我们使用不同规模的二叉树进行遍历实验，并记录遍历的结果和所花费的时间。
通过对比不同规模下不同遍历方式的结果和时间，我们可以评估遍历算法的效率和准确性。
三、实验结果和分析在实验中，我们构建了一棵具有1000个节点的二叉树，并分别使用前序、中序和后序遍历算法进行遍历。
通过实验结果的比较，我们得出以下结论：1. 遍历结果的正确性：无论是前序、中序还是后序遍历，我们都能够正确地访问到二叉树中的每个节点。
这表明我们所实现的遍历算法是正确的。
2. 遍历算法的效率：在1000个节点的二叉树中，我们发现中序遍历算法的执行时间最短，后序遍历算法的执行时间最长，前序遍历算法的执行时间居中。
这是因为中序遍历算法在访问节点时可以尽可能地减少递归次数，而后序遍历算法需要递归到最深层才能返回。
数据结构二叉树遍历实验报告
数据结构二叉树遍历实验报告数据结构二叉树遍历实验报告一、引言本文档旨在详细介绍二叉树遍历的实验过程和结果。
二叉树是一种在计算机科学领域常用的数据结构，通过遍历二叉树可以获取树中的所有节点数据。
本实验将分别介绍前序遍历、中序遍历和后序遍历这三种常见的遍历方法。
二、实验目的本实验的目的是通过实际操作，加深对二叉树遍历方法的理解，并验证这些遍历方法的正确性和效率。
三、实验环境本实验使用的环境如下：●操作系统: Windows 10●开发工具: Visual Studio Code●编程语言: C++四、实验步骤1.创建二叉树数据结构1.1 定义二叉树节点的结构，包含数据和左右子节点指针。
1.2 创建一个二叉树类，包含插入节点、删除节点、查找节点等方法。
1.3 使用已有的数据集构建二叉树，确保树的结构合理。
2.前序遍历前序遍历是先访问根节点，然后递归地遍历左子树和右子树。
2.1 以递归方式实现前序遍历。
2.2 以迭代方式实现前序遍历。
3.中序遍历中序遍历是先遍历左子树，然后访问根节点，最后遍历右子树。
3.1 以递归方式实现中序遍历。
3.2 以迭代方式实现中序遍历。
4.后序遍历后序遍历是先遍历左子树，然后遍历右子树，最后访问根节点。
4.1 以递归方式实现后序遍历。
4.2 以迭代方式实现后序遍历。
五、实验结果1.前序遍历结果：[节点1数据] [节点2数据] [节点4数据] [节点5数据] [节点3数据]2.中序遍历结果：[节点4数据] [节点2数据] [节点5数据] [节点1数据] [节点3数据]3.后序遍历结果：[节点4数据] [节点5数据] [节点2数据] [节点3数据] [节点1数据]六、实验分析通过实验结果可以看出，不同的遍历顺序得到的节点顺序也不同。
前序遍历先访问根节点，中序遍历先遍历左子树，后序遍历先遍历右子树。
根据需要，可以选择合适的遍历方法来处理二叉树的节点数据。
七、结论本实验验证了前序遍历、中序遍历和后序遍历的正确性，并且对比了它们的不同。
二叉树的建立和遍历的实验报告doc
二叉树的建立和遍历的实验报告篇一：二叉树的建立及遍历实验报告实验三：二叉树的建立及遍历【实验目的】（1）掌握利用先序序列建立二叉树的二叉链表的过程。
（2）掌握二叉树的先序、中序和后序遍历算法。
【实验内容】1. 编写程序，实现二叉树的建立，并实现先序、中序和后序遍历。
如：输入先序序列abc###de###，则建立如下图所示的二叉树。
并显示其先序序列为：abcde中序序列为：cbaed后序序列为：cbeda【实验步骤】1.打开VC++。
2.建立工程：点File->New，选Project标签，在列表中选Win32 Console Application，再在右边的框里为工程起好名字，选好路径，点OK->finish。
至此工程建立完毕。
3.创建源文件或头文件：点File->New，选File标签，在列表里选C++ Source File。
给文件起好名字，选好路径，点OK。
至此一个源文件就被添加到了你刚创建的工程之中。
4．写好代码5．编译－＞链接－＞调试#include#include#define OK 1#define OVERFLOW -2typedef int Status;typedef char TElemType;typedef struct BiTNode{TElemType data;struct BiTNode *lchild, *rchild;}BiTNode,*BiTree;Status CreateBiTree(BiTree &T){TElemType ch;scanf("%c",&ch);if (ch=='#')T= NULL;else{if (!(T = (BiTNode *)malloc(sizeof(BiTNode))))return OVERFLOW;T->data = ch; CreateBiTree(T->lchild); CreateBiTree(T->rchild); }return OK;} // CreateBiTreevoid PreOrder(BiTree T) {if(T){printf("%c",T->data); PreOrder(T->lchild); PreOrder(T->rchild);}}void InOrder(BiTree T) {if(T){InOrder(T->lchild);printf("%c",T->data);InOrder(T->rchild);}}void PostOrder(BiTree T){if(T){PostOrder(T->lchild); PostOrder(T->rchild);printf("%c",T->data);}}void main(){BiTree T;CreateBiTree(T);printf("\n先序遍历序列:"); PreOrder(T);printf("\n中序遍历序列:"); InOrder(T);printf("\n后序遍历序列:"); PostOrder(T);}【实验心得】这次实验主要是通过先序序列建立二叉树，和二叉树的先序、中序、后续遍历算法。
二叉树的遍历算法实验报告
二叉树的遍历算法实验报告二叉树的遍历算法实验报告引言：二叉树是计算机科学中常用的数据结构之一，它是由节点组成的层次结构，每个节点最多有两个子节点。
在实际应用中，对二叉树进行遍历是一项重要的操作，可以帮助我们理解树的结构和节点之间的关系。
本文将介绍二叉树的三种遍历算法：前序遍历、中序遍历和后序遍历，并通过实验验证其正确性和效率。
一、前序遍历前序遍历是指先访问根节点，然后按照先左后右的顺序遍历左右子树。
具体的实现可以通过递归或者使用栈来实现。
我们以递归方式实现前序遍历算法，并进行实验验证。
实验步骤：1. 创建一个二叉树，并手动构造一些节点和它们之间的关系。
2. 实现前序遍历算法的递归函数，函数的输入为根节点。
3. 在递归函数中，首先访问当前节点，然后递归调用函数遍历左子树，最后递归调用函数遍历右子树。
4. 调用前序遍历函数，输出遍历结果。
实验结果：经过实验，我们得到了正确的前序遍历结果。
这证明了前序遍历算法的正确性。
二、中序遍历中序遍历是指按照先左后根再右的顺序遍历二叉树。
同样，我们可以使用递归或者栈来实现中序遍历算法。
在本实验中，我们选择使用递归方式来实现。
实验步骤：1. 继续使用前面创建的二叉树。
2. 实现中序遍历算法的递归函数，函数的输入为根节点。
3. 在递归函数中，首先递归调用函数遍历左子树，然后访问当前节点，最后递归调用函数遍历右子树。
4. 调用中序遍历函数，输出遍历结果。
实验结果：通过实验，我们得到了正确的中序遍历结果。
这证明了中序遍历算法的正确性。
三、后序遍历后序遍历是指按照先左后右再根的顺序遍历二叉树。
同样，我们可以使用递归或者栈来实现后序遍历算法。
在本实验中，我们选择使用递归方式来实现。
实验步骤：1. 继续使用前面创建的二叉树。
2. 实现后序遍历算法的递归函数，函数的输入为根节点。
3. 在递归函数中，首先递归调用函数遍历左子树，然后递归调用函数遍历右子树，最后访问当前节点。
4. 调用后序遍历函数，输出遍历结果。
二叉树遍历的实习报告
实习报告实习内容：二叉树遍历实习时间：2023实习单位：某高校计算机实验室一、实习目的本次实习的主要目的是通过实现二叉树的遍历，加深对二叉树数据结构的理解，掌握二叉树的常见操作，提高编程能力。
二、实习内容1. 理解二叉树的基本概念和性质，包括节点之间的关系、树的深度、高度等。
2. 掌握二叉树的存储结构，包括顺序存储和链式存储。
3. 实现二叉树的前序遍历、中序遍历和后序遍历。
4. 通过实际编程，验证二叉树遍历的正确性。
三、实习过程1. 二叉树的基本概念和性质：二叉树是一种非线性的数据结构，每个节点最多有两个子节点。
节点之间的关系包括父子关系、兄弟关系等。
树的深度是指从根节点到最远叶子节点的最长路径上的边数，高度是指从根节点到最远叶子节点的最长路径上的边数加1。
2. 二叉树的存储结构：二叉树可以用顺序存储结构或链式存储结构表示。
顺序存储结构使用数组来实现，每个节点存储在数组的一个位置中，节点之间的父子关系通过数组下标来表示。
链式存储结构使用链表来实现，每个节点包含数据域和两个指针域，分别指向左子节点和右子节点。
3. 二叉树的遍历：二叉树的遍历是指按照一定的顺序访问树中的所有节点。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
前序遍历是指先访问根节点，然后递归遍历左子树，最后递归遍历右子树。
中序遍历是指先递归遍历左子树，然后访问根节点，最后递归遍历右子树。
后序遍历是指先递归遍历左子树，然后递归遍历右子树，最后访问根节点。
4. 编程实现：根据二叉树的存储结构和遍历方法，编写C语言程序实现二叉树的前序遍历、中序遍历和后序遍历。
程序中使用递归函数来实现遍历操作，通过建立链式存储结构，验证遍历的正确性。
四、实习心得通过本次实习，我对二叉树的数据结构有了更深入的了解，掌握了二叉树的存储方式和常见操作。
在实现二叉树遍历的过程中，我学会了如何使用递归函数解决问题，提高了编程能力。
同时，通过实际编程验证了二叉树遍历的正确性，增强了对算法理解的信心。
二叉树的遍历实验报告
二叉树的遍历实验报告实验报告：二叉树的遍历（先序遍历、中序遍历、后序遍历）一、引言二叉树是一种非常常见的数据结构，在计算机领域有着广泛的应用。
对二叉树进行遍历操作是其中最基本的操作之一、本实验旨在通过对二叉树的先序遍历、中序遍历和后序遍历的实践，加深对二叉树遍历算法的理解和掌握。
二、目的1.掌握二叉树先序遍历的算法原理和实现方法；2.掌握二叉树中序遍历的算法原理和实现方法；3.掌握二叉树后序遍历的算法原理和实现方法；4.使用递归和非递归两种方式实现以上三种遍历算法；5.进行正确性验证和性能评估。
三、方法1.算法原理：1.1先序遍历：先访问根节点，然后递归遍历左子树，再递归遍历右子树；1.2中序遍历：先递归遍历左子树，然后访问根节点，最后递归遍历右子树；1.3后序遍历：先递归遍历左子树，再递归遍历右子树，最后访问根节点。
2.实现方法：2.1递归实现：采用函数递归调用的方式，实现对二叉树的遍历；2.2非递归实现：采用栈的数据结构，模拟递归的过程，实现对二叉树的遍历。
四、实验步骤1.数据结构设计：1.1定义二叉树的节点结构，包括节点值和两个指针（分别指向左子节点和右子节点）；1.2定义一个栈结构，用于非递归实现时的辅助存储。
2.先序遍历：2.1递归实现：按照先序遍历的原理，通过递归调用遍历左子树和右子树，再输出根节点；2.2非递归实现：通过栈结构模拟递归的过程，先将根节点入栈，然后循环将栈顶节点弹出并输出，再将其右子节点入栈，最后将左子节点入栈，直到栈为空。
3.中序遍历：3.1递归实现：按照中序遍历的原理，通过递归调用先遍历左子树，再输出根节点，最后遍历右子树；3.2非递归实现：先将根节点入栈，然后循环将左子节点入栈，直到左子节点为空，然后弹出栈顶节点并输出，再将其右子节点入栈，重复以上过程直到栈为空。
4.后序遍历：4.1递归实现：按照后序遍历的原理，通过递归调用先遍历左子树，再遍历右子树，最后输出根节点；4.2非递归实现：通过栈结构模拟递归的过程，先将根节点入栈，然后重复以下步骤直到栈为空。
二叉树递归遍历数据结构实验报告
二叉树递归遍历数据结构实验报告一、引言二叉树是一种简单而重要的树形结构，在计算机科学领域中被广泛应用。
它具有良好的动态性能和数据组织能力，递归遍历是二叉树最基本的操作之一、本次实验旨在通过编程实现二叉树的递归遍历算法，并对实验结果进行分析和总结。
二、实验目的1.掌握二叉树的基本概念和操作方法；2.熟悉递归算法的实现过程；3.实践二叉树的递归遍历算法。
三、实验原理1.二叉树的概念二叉树是一种树形结构，其中每个节点最多有两个子节点，被分为左子树和右子树。
树中每个节点最多有一个父节点，除了根节点没有父节点。
二叉树的递归定义：（1）空树是一个二叉树；（2）一棵非空二叉树由根节点和左子树、右子树组成。
2.二叉树的递归遍历二叉树的遍历方式分为三种：前序遍历、中序遍历和后序遍历。
其定义如下：（1）前序遍历：根节点->左子树->右子树；（2）中序遍历：左子树->根节点->右子树；（3）后序遍历：左子树->右子树->根节点。
四、实验过程1.定义二叉树的数据结构和相关操作方法首先，我们需要定义二叉树的节点结构，包含数据域和左右子节点指针域。
然后，可定义插入节点、删除节点等操作方法。
2.实现递归遍历算法（1）前序遍历前序遍历的流程为：先访问根节点，再前序遍历左子树，最后前序遍历右子树。
通过递归调用即可实现。
伪代码如下：```void preOrder(Node* root)if (root != NULL)cout << root->data;preOrder(root->left);preOrder(root->right);}（2）中序遍历和后序遍历与前序遍历类似，中序遍历的流程为：先中序遍历左子树，再访问根节点，最后中序遍历右子树。
后序遍历的流程为：先后序遍历左子树，再后序遍历右子树，最后访问根节点。
也可以通过递归调用实现。
伪代码如下：```void inOrder(Node* root)if (root != NULL)inOrder(root->left);cout << root->data;inOrder(root->right);}void postOrder(Node* root)if (root != NULL)postOrder(root->left);postOrder(root->right);cout << root->data;}五、实验结果与分析我们通过编写测试数据并调用递归遍历算法进行遍历，得到以下结果：（1）前序遍历结果：ABDECFG（2）中序遍历结果：DBEAFCG（3）后序遍历结果：DEBFGCA实验结果与预期相符，表明递归遍历算法编写正确。
遍历二叉树实验报告
遍历二叉树实验报告遍历二叉树实验报告引言：二叉树是一种常见的数据结构，它由节点组成，每个节点最多有两个子节点。
在实际应用中，对二叉树进行遍历是一项重要的操作。
本实验旨在通过实际操作，探索二叉树的遍历算法，并分析其时间复杂度和空间复杂度。
一、实验目的通过实际操作，掌握二叉树的前序遍历、中序遍历和后序遍历算法，并分析它们的特点和适用场景。
二、实验环境本实验使用C++语言进行编程，运行环境为Windows操作系统。
三、实验过程1. 创建二叉树首先，我们需要创建一个二叉树作为实验的基础数据结构。
在本实验中，我们选择手动创建一个简单的二叉树，以便更好地理解遍历算法的实现过程。
2. 前序遍历前序遍历是一种深度优先遍历算法，它的遍历顺序是先访问根节点，然后递归地遍历左子树和右子树。
通过实际操作，我们可以发现前序遍历的结果是根节点在最前面。
3. 中序遍历中序遍历也是一种深度优先遍历算法，它的遍历顺序是先递归地遍历左子树，然后访问根节点，最后递归地遍历右子树。
通过实际操作，我们可以发现中序遍历的结果是根节点在中间。
4. 后序遍历后序遍历同样是一种深度优先遍历算法，它的遍历顺序是先递归地遍历左子树和右子树，最后访问根节点。
通过实际操作，我们可以发现后序遍历的结果是根节点在最后面。
5. 分析与总结通过对前序遍历、中序遍历和后序遍历的实际操作，我们可以得出以下结论：- 前序遍历适合于需要先处理根节点的场景，例如树的构建和复制。
- 中序遍历适合于需要按照节点值的大小顺序进行处理的场景，例如搜索二叉树的构建和排序。
- 后序遍历适合于需要先处理叶子节点的场景，例如树的销毁和内存释放。
四、实验结果通过实际操作，我们成功实现了二叉树的前序遍历、中序遍历和后序遍历算法，并得到了相应的遍历结果。
这些结果验证了我们对遍历算法的分析和总结的正确性。
五、实验总结本实验通过实际操作，深入探索了二叉树的遍历算法，并分析了它们的特点和适用场景。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
问题一：二叉树遍历1.问题描述设输入该二叉树的前序序列为：ABC##DE#G##F##HI##J#K##（#代表空子树）请编程完成下列任务：⑴请根据此输入来建立该二叉树，并输出该二叉树的前序、中序和后序序列；⑵按层次遍历的方法来输出该二叉树按层次遍历的序列；⑶求该二叉树的高度。
2.设计描述（1）二叉树是一种树形结构，遍历就是要让树中的所有节点被且仅被访问一次，即按一定规律排列成一个线性队列。
二叉（子）树是一种递归定义的结构，包含三个部分：根结点（N）、左子树（L）、右子树（R）。
根据这三个部分的访问次序对二叉树的遍历进行分类，总共有6种遍历方案：NLR、LNR、LRN、NRL、RNL和LNR。
研究二叉树的遍历就是研究这6种具体的遍历方案，显然根据简单的对称性，左子树和右子树的遍历可互换，即NLR与NRL、LNR与RNL、LRN 与RLN，分别相类似，因而只需研究NLR、LNR和LRN三种即可，分别称为“先序遍历”、“中序遍历”和“后序遍历”。
采用递归方式就可以容易的实现二叉树的遍历，算法简单且直观。
（2）此外，二叉树的层次遍历即按照二叉树的层次结构进行遍历，按照从上到下，同一层从左到右的次序访问各节点。
遍历算法可以利用队列来实现，开始时将整个树的根节点入队，然后每从队列中删除一个节点并输出该节点的值时，都将它的非空的左右子树入队，当队列结束时算法结束。
（3）计算二叉树高度也是利用递归来实现：若一颗二叉树为空，则它的深度为0，否则深度等于左右子树的最大深度加一。
3．源程序1 2 3 4 5 6 7 8 91011121314 #include <stdio.h>#include <stdlib.h>#include <malloc.h>#define ElemType charstruct BTreeNode {ElemType data;struct BTreeNode* left;struct BTreeNode* right;};void CreateBTree(struct BTreeNode** T) {char ch;scanf_s("\n%c", &ch);if (ch == '#') *T = NULL;15161718192021222324252627282930313233343536else {(*T) = malloc(sizeof(struct BTreeNode));(*T)->data = ch;CreateBTree(&((*T)->left));CreateBTree(&((*T)->right));}}void Preorder(struct BTreeNode* T){if (T != NULL) {printf("%c ", T->data);Preorder(T->left);Preorder(T->right);}}void Inorder(struct BTreeNode* T){if (T != NULL) {Inorder(T->left);printf("%c ", T->data);Inorder(T->right);}37383940414243444546474849505152535455565758 }void Postorder(struct BTreeNode* T) {if (T != NULL) {Postorder(T->left);Postorder(T->right);printf("%c ", T->data);}}void Levelorder(struct BTreeNode* BT) {struct BTreeNode* p;struct BTreeNode* q[30];int front=0,rear=0;if(BT!=NULL) {rear=(rear+1)% 30;q[rear]=BT;}while(front!=rear) {front=(front+1)% 30;p=q[front];printf("%c ",p->data);59606162636465666768697071727374757677787980if(p->left!=NULL) {rear=(rear+1)% 30;q[rear]=p->left;}if(p->right!=NULL) {rear=(rear+1)% 30;q[rear]=p->right;}}}int getHeight(struct BTreeNode* T) {int lh,rh;if (T == NULL) return 0;lh = getHeight(T->left);rh = getHeight(T->right);return lh>rh ? lh + 1 : rh + 1; }void main(void){struct BTreeNode* T;CreateBTree(&T);8182838485868788899091929394printf("前序序列：\n");Preorder(T);printf("\n");printf("中序序列：\n");Inorder(T);printf("\n");printf("后序序列：\n");Postorder(T);printf("\n");printf("层次遍历序列：\n");Levelorder(T);printf("\n");printf("二叉树高度：%d\n", getHeight(T)); }4.运行结果问题二：哈夫曼编码、译码系统1.问题描述对一个ASCII编码的文本文件中的字符进行哈夫曼编码，生成编码文件；反过来，可将编码文件译码还原为一个文本文件（选做）。
❖从文件中读入给定的一篇英文短文（文件为ASCII编码，扩展名为txt）；❖统计并输出不同字符在文章中出现的频率（空格、换行、标点等不按字符处理）；❖根据字符频率构造哈夫曼树，并给出每个字符的哈夫曼编码；❖将文本文件利用哈夫曼树进行编码，存储成编码文件（编码文件后缀名.huf）❖进行译码，将huf文件译码为ASCII编码的txt文件，与原txt文件进行比较。
（选做）2.设计描述（1）统计并输出不同字符在文章中出现的频率，通过建立两个数组chs和chs_freq来实现，chs存储文件中出现过的字符，chs_freq（初始化为全0）存储对应字符在文件中出现的频数，当扫描一个字符时，先与chs中已有字符进行比较，若数组中存在该字符，则将该字符对应频数加1，否则则将该字符加入数组，并频数加1。
（2）根据字符频率构造哈夫曼树，即将chs_freq数组作为权值数组，建立哈夫曼树，为了方便后续操作，为结构体BtreeNode添加一个新的成员变量symbol，建立二叉树时用以存储对应权值的字符。
（3）通过最优二叉树（哈夫曼树）输出每个字符的哈夫曼编码，是利用递归实现的，访问非叶子节点时，分别向左右子树递归调用，并将分支上的01编码保存到数组a对应元素中，向下一层len++。
访问到非叶子节点时输出其保存在数组中的编码序列，并将其保存至哈夫曼编码文件orde.code。
（4）将文本文件利用哈夫曼树进行编码：每从文本文件中读取一个字符，则在哈夫曼编码文件order.code查找该字符，查找到后将该字符对应哈夫曼编码写入编码后文件order.huf。
并将order.code文件指针重新指向开头，准备对下一个字符进行操作。
3．源程序1 2 3 4 5 6 7 8 910111213141516171819202122232425262728293031323334 #include <stdio.h>#include <stdlib.h>typedef int ElemType;struct BTreeNode {ElemType data;struct BTreeNode* left;struct BTreeNode* right;char symbol;};void CountChar(FILE *fp,char* chs,int* ch_freq) {int num = 0;int i,tmp;char ch = fgetc(fp);while (ch != EOF){if ((ch>64 && ch<91)||(ch>96 && ch<123)) {for (tmp = 0; tmp <= num; tmp++){if (ch == chs[tmp]) { ch_freq[tmp]++; break; }if (tmp == num) { chs[num] = ch; ch_freq[num]++; num++; break; }}}ch = fgetc(fp);}chs[num]='\0';for (i = 0; i < num; i++) printf("%c %d\n", chs[i], ch_freq[i]);}struct BTreeNode* CreateHuffman(ElemType a[], int n,char ss[]) { int i, j;struct BTreeNode **b, *q;q = malloc(sizeof(struct BTreeNode));b = malloc(n*sizeof(struct BTreeNode*));for (i = 0; i < n; i++) {3536373839404142434445464748495051525354555657585960616263646566676869707172737475767778b[i] = malloc(sizeof(struct BTreeNode));b[i]->data = a[i]; b[i]->left = b[i]->right = NULL;b[i]->symbol = ss[i];}for (i = 1; i < n; i++) {int k1 = -1, k2;for (j = 0; j < n; j++) {if (b[j] != NULL &&k1 == -1) { k1 = j; continue; }if (b[j] != NULL) { k2 = j; break; }}for (j = k2; j < n; j++) {if (b[j] != NULL) {if (b[j]->data < b[k1]->data) { k2 = k1; k1 = j; }else if (b[j]->data < b[k2]->data) k2 = j;}}q = malloc(sizeof(struct BTreeNode));q->data = b[k1]->data + b[k2]->data;q->left = b[k1]; q->right = b[k2];b[k1] = q; b[k2] = NULL;}free(b);return q;};void HuffCoding(struct BTreeNode* FBT, int len) {static int a[50];char tmp;FILE *fp;int i;if(len == 0) fp=fopen("order.code","w");if((fp=fopen("order.code","a")) == NULL) {printf("文件打开失败！\n");exit(1);} if (FBT != NULL) {if (FBT->left == NULL && FBT->right == NULL) {printf("%c霍夫曼编码为：", FBT->symbol);fputc(FBT->symbol,fp);fputc('\t',fp);for (i = 0; i < len; i++) {printf("%d", a[i]);tmp=a[i]+48;fputc(tmp,fp);}printf("\n");fputc('\n',fp);}else {a[len] = 0; HuffCoding(FBT->left, len + 1);798081828384858687888990919293949596979899 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122a[len] = 1; HuffCoding(FBT->right, len + 1);}}fclose(fp);}void TransCode(FILE *src) {FILE *fp1,*fp2;char ch1,ch2;if((fp1=fopen("order.code","r")) == NULL) {printf("文件打开失败！\n");exit(1);} if((fp2=fopen("order.huf","w")) == NULL) {printf("文件打开失败！\n");exit(1);} fseek(src,0L,SEEK_SET);ch1 = fgetc(src);ch2 = fgetc(fp1);while (ch1 != EOF){if ((ch1>64 && ch1<91)||(ch1>96 && ch1<123)) {while(ch2 != EOF) {if(ch2 == ch1){fgetc(fp1);ch2=fgetc(fp1);while(ch2!='\n'){fputc(ch2,fp2);ch2=fgetc(fp1);}fputc('\t',fp2);break;}ch2 = fgetc(fp1);if(ch2 == EOF) printf("未找到对应编码!\n");}rewind(fp1);ch2 = fgetc(fp1);}ch1 = fgetc(src);}fclose(fp1);fclose(fp2);}void main(void){char chs[100];int ch_freq[100] = {0};struct BTreeNode* T;123 124 125 126 127 128 129FILE *fp;if((fp=fopen("order.txt","r")) == NULL) {printf("文件打开失败！\n");exit(1);} CountChar(fp,chs,ch_freq);T = CreateHuffman(ch_freq,strlen(chs),chs);HuffCoding(T,0);TransCode(fp);fclose(fp);}4.运行结果。