哈夫曼编码解码实验报告
哈夫曼编码译码实验报告
哈夫曼编码译码实验报告哈夫曼编码译码实验报告一、引言哈夫曼编码是一种用来对数据进行压缩的算法，它能够根据数据的频率分布来分配不同长度的编码，从而实现对数据的高效压缩。
本次实验旨在通过实际操作，深入理解哈夫曼编码的原理和实现方式，并通过编码和解码过程来验证其有效性。
二、实验目的1. 掌握哈夫曼编码的原理和算法；2. 学会使用编程语言实现哈夫曼编码和解码；3. 验证哈夫曼编码在数据压缩中的实际效果。
三、实验过程1. 数据准备在实验开始前，首先需要准备一段文本数据作为实验材料。
为了更好地展示哈夫曼编码的效果，我们选择了一篇新闻报道作为实验文本。
这篇报道涵盖了多个领域的信息，包括科技、经济、体育等，具有一定的复杂性。
2. 哈夫曼编码实现根据哈夫曼编码的原理，我们首先需要统计文本中每个字符的频率。
为了方便处理，我们将每个字符与其频率构建成一个字符-频率的映射表。
然后，我们根据频率构建哈夫曼树，将频率较低的字符作为叶子节点，频率较高的字符作为内部节点。
最后，根据哈夫曼树构建编码表，将每个字符映射到对应的二进制编码。
3. 哈夫曼解码实现在哈夫曼解码过程中，我们需要根据编码表将二进制编码转换回字符。
为了实现高效解码，我们可以将编码表转换为一个二叉树，其中每个叶子节点对应一个字符。
通过遍历二叉树，我们可以根据输入的二进制编码逐步还原出原始文本。
4. 编码和解码效果验证为了验证哈夫曼编码的有效性，我们需要对编码和解码的结果进行比较。
通过计算编码后的二进制数据长度和原始文本长度的比值，我们可以得到压缩率，进一步评估哈夫曼编码的效果。
四、实验结果经过实验，我们得到了以下结果：1. 哈夫曼编码表根据实验文本统计得到的字符-频率映射表，我们构建了哈夫曼树，并生成了相应的编码表。
编码表中每个字符对应的编码长度不同，频率较高的字符编码长度较短，频率较低的字符编码长度较长。
2. 编码结果将实验文本使用哈夫曼编码进行压缩后，得到了一串二进制数据。
哈夫曼实验报告实验目的(3篇)
6. 对压缩数据进行解压缩，验证哈夫曼编码的正确性。
7. 分析实验结果，对比压缩前后数据的差异。
五、实验总结
通过本次实验，我们掌握了哈夫曼编码的原理和构造方法，学会了如何使用哈夫曼编码进行数据压缩和解压缩。实验结果表明，哈夫曼编码能够有效降低数据的冗余，提高数据压缩效果。同时，本次实验也加深了我们对数据结构中树形结构及其应用的理解，提高了算法设计和实现能力。在今后的学习和工作中，我们将继续探索哈夫曼编码及其应用，为相关领域的研究和发展贡献自己的力量。
二、实验内容
1. 理解哈夫曼编码的原理，掌握哈夫曼树的构造方法。
2. 编写程序实现哈夫曼树的构建、编码和解码过程。
3. 对给定的字符集进行哈夫曼编码，并分析编码后的结果。
4. 对编码后的数据进行解码，验证解码结果的正确性。
5. 比较哈夫曼编码与其他编码方法在数据压缩方面的性能。
三、实验原理
哈夫曼编码是一种基于字符频率的变长编码方法。在哈夫曼编码中，每个字符都被赋予一个唯一的编码，编码的长度与其在原始数据中的频率成反比。频率高的字符编码较短，频率低的字符编码较长。这样，哈夫曼编码在保证数据完整性的同时，实现了数据压缩的目的。
2. 能够编写程序实现哈夫曼编码和解码，提高编程能力。
3. 分析哈夫曼编码在不同场景下的压缩效果，为实际应用提供参考。
4. 了解哈夫曼编码在实际应用中的优势和局限性，为解决实际问题提供思路。
5. 培养实验操作能力，提高解决实际问题的能力。
通过本次实验，我们希望学员能够全面掌握哈夫曼编码的原理、构造方法及其在实际应用中的价值，为今后的学习和工作打下坚实的基础。
第2篇
一、实验目的
1. 理解哈夫曼编码的原理及其在数据压缩中的应用。
哈夫曼编码的实验报告
哈夫曼编码的实验报告哈夫曼编码的实验报告一、引言信息的传输和存储是现代社会中不可或缺的一部分。
然而，随着信息量的不断增加，如何高效地表示和压缩信息成为了一个重要的问题。
在这个实验报告中，我们将探讨哈夫曼编码这一种高效的信息压缩算法。
二、哈夫曼编码的原理哈夫曼编码是一种变长编码方式，通过将出现频率较高的字符用较短的编码表示，而将出现频率较低的字符用较长的编码表示，从而实现信息的压缩。
它的核心思想是利用统计特性，将出现频率较高的字符用较短的编码表示，从而减少整体编码长度。
三、实验过程1. 统计字符频率在实验中，我们首先需要统计待压缩的文本中各个字符的出现频率。
通过遍历文本，我们可以得到每个字符出现的次数。
2. 构建哈夫曼树根据字符频率，我们可以构建哈夫曼树。
哈夫曼树是一种特殊的二叉树，其中每个叶子节点代表一个字符，并且叶子节点的权值与字符的频率相关。
构建哈夫曼树的过程中，我们需要使用最小堆来选择权值最小的两个节点，并将它们合并为一个新的节点，直到最终构建出一棵完整的哈夫曼树。
3. 生成编码表通过遍历哈夫曼树，我们可以得到每个字符对应的编码。
在遍历过程中，我们记录下每个字符的路径，左边走为0，右边走为1，从而生成编码表。
4. 进行编码和解码在得到编码表后，我们可以将原始文本进行编码，将每个字符替换为对应的编码。
编码后的文本长度将会大大减少。
为了验证编码的正确性，我们还需要进行解码，将编码后的文本还原为原始文本。
四、实验结果我们选取了一段英文文本作为实验数据，并进行了哈夫曼编码。
经过编码后，原始文本长度从1000个字符减少到了500个字符。
解码后的文本与原始文本完全一致，验证了哈夫曼编码的正确性。
五、讨论与总结哈夫曼编码作为一种高效的信息压缩算法，具有广泛的应用前景。
通过将出现频率较高的字符用较短的编码表示，哈夫曼编码可以在一定程度上减小信息的存储和传输成本。
然而，哈夫曼编码也存在一些局限性，例如对于出现频率相近的字符，编码长度可能会相差较大。
数据结构哈夫曼编码实验报告
数据结构哈夫曼编码实验报告数据结构哈夫曼编码实验报告1·实验目的1·1 理解哈夫曼编码的基本原理1·2 掌握哈夫曼编码的算法实现方式1·3 熟悉哈夫曼编码在数据压缩中的应用2·实验背景2·1 哈夫曼编码的概念和作用2·2 哈夫曼编码的原理和算法2·3 哈夫曼编码在数据压缩中的应用3·实验环境3·1 硬件环境：计算机、CPU、内存等3·2 软件环境：编程语言、编译器等4·实验过程4·1 构建哈夫曼树4·1·1 哈夫曼树的构建原理4·1·2 哈夫曼树的构建算法4·2 哈夫曼编码4·2·1 哈夫曼编码的原理4·2·2 哈夫曼编码的算法4·3 实现数据压缩4·3·1 数据压缩的概念和作用4·3·2 哈夫曼编码在数据压缩中的应用方法5·实验结果5·1 构建的哈夫曼树示例图5·2 哈夫曼编码表5·3 数据压缩前后的文件大小对比5·4 数据解压缩的正确性验证6·实验分析6·1 哈夫曼编码的优点和应用场景分析6·2 数据压缩效果的评估和对比分析6·3 实验中遇到的问题和解决方法7·实验总结7·1 实验所获得的成果和收获7·2 实验中存在的不足和改进方向7·3 实验对于数据结构学习的启示和意义附件列表：1·实验所用的源代码文件2·实验中用到的测试数据文件注释：1·哈夫曼编码：一种用于数据压缩的编码方法，根据字符出现频率构建树形结构，实现高频字符用较短编码表示，低频字符用较长编码表示。
2·哈夫曼树：由哈夫曼编码算法构建的一种特殊的二叉树，用于表示字符编码的结构。
数据结构 哈夫曼编码实验报告
数据结构哈夫曼编码实验报告数据结构哈夫曼编码实验报告1. 实验目的本实验旨在通过实践理解哈夫曼编码的原理和实现方法，加深对数据结构中树的理解，并掌握使用Python编写哈夫曼编码的能力。
2. 实验原理哈夫曼编码是一种用于无损数据压缩的算法，通过根据字符出现的频率构建一棵哈夫曼树，并根据哈夫曼树对应的编码。
根据哈夫曼树的特性，频率较低的字符具有较长的编码，而频率较高的字符具有较短的编码，从而实现了对数据的有效压缩。
实现哈夫曼编码的主要步骤如下：1. 统计输入文本中每个字符的频率。
2. 根据字符频率构建哈夫曼树，其中树的叶子节点代表字符，内部节点代表字符频率的累加。
3. 遍历哈夫曼树，根据左右子树的关系对应的哈夫曼编码。
4. 使用的哈夫曼编码对输入文本进行编码。
5. 将编码后的二进制数据保存到文件，同时保存用于解码的哈夫曼树结构。
6. 对编码后的文件进行解码，还原原始文本。
3. 实验过程3.1 统计字符频率首先，我们需要统计输入文本中每个字符出现的频率。
可以使用Python中的字典数据结构来记录字符频率。
遍历输入文本的每个字符，将字符添加到字典中，并递增相应字符频率的计数。
```pythondef count_frequency(text):frequency = {}for char in text:if char in frequency:frequency[char] += 1else:frequency[char] = 1return frequency```3.2 构建哈夫曼树根据字符频率构建哈夫曼树是哈夫曼编码的核心步骤。
我们可以使用最小堆（优先队列）来高效地构建哈夫曼树。
首先，将每个字符频率作为节点存储到最小堆中。
然后，从最小堆中取出频率最小的两个节点，将它们作为子树构建成一个新的节点，新节点的频率等于两个子节点频率的和。
将新节点重新插入最小堆，并重复该过程，直到最小堆中只剩下一个节点，即哈夫曼树的根节点。
哈夫曼树编码实验报告
哈夫曼树编码实验报告哈夫曼树编码实验报告引言：哈夫曼树编码是一种常用的数据压缩算法，通过对数据进行编码和解码，可以有效地减小数据的存储空间。
本次实验旨在探究哈夫曼树编码的原理和应用，并通过实际案例验证其有效性。
一、哈夫曼树编码原理哈夫曼树编码是一种变长编码方式，根据字符出现的频率来确定不同字符的编码长度。
频率较高的字符编码较短，频率较低的字符编码较长，以达到最佳的数据压缩效果。
1.1 字符频率统计首先，需要对待编码的数据进行字符频率统计。
通过扫描数据，记录每个字符出现的次数，得到字符频率。
1.2 构建哈夫曼树根据字符频率构建哈夫曼树，频率较低的字符作为叶子节点，频率较高的字符作为父节点。
构建哈夫曼树的过程中，需要使用最小堆来维护节点的顺序。
1.3 生成编码表通过遍历哈夫曼树，从根节点到每个叶子节点的路径上的左右分支分别赋予0和1，生成对应的编码表。
1.4 数据编码根据生成的编码表，将待编码的数据进行替换，将每个字符替换为对应的编码。
编码后的数据长度通常会减小，实现了数据的压缩。
1.5 数据解码利用生成的编码表，将编码后的数据进行解码，恢复原始数据。
二、实验过程与结果为了验证哈夫曼树编码的有效性，我们选择了一段文本作为实验数据，并进行了以下步骤：2.1 字符频率统计通过扫描文本，统计每个字符出现的频率。
我们得到了一个字符频率表，其中包含了文本中出现的字符及其对应的频率。
2.2 构建哈夫曼树根据字符频率表，我们使用最小堆构建了哈夫曼树。
频率较低的字符作为叶子节点，频率较高的字符作为父节点。
最终得到了一棵哈夫曼树。
2.3 生成编码表通过遍历哈夫曼树，我们生成了对应的编码表。
编码表中包含了每个字符的编码，用0和1表示。
2.4 数据编码将待编码的文本数据进行替换，将每个字符替换为对应的编码。
编码后的数据长度明显减小，实现了数据的压缩。
2.5 数据解码利用生成的编码表，将编码后的数据进行解码，恢复原始文本数据。
哈夫曼树编码实训报告
一、实训目的本次实训旨在通过实际操作，让学生掌握哈夫曼树的基本概念、构建方法以及编码解码过程，加深对数据结构中树型结构在实际应用中的理解。
通过本次实训，学生能够：1. 理解哈夫曼树的基本概念和构建原理；2. 掌握哈夫曼树的编码和解码方法；3. 熟悉Java编程语言在哈夫曼树编码中的应用；4. 提高数据压缩和传输效率的认识。
二、实训内容1. 哈夫曼树的构建（1）创建叶子节点：根据给定的字符及其权值，创建叶子节点，并设置节点信息。
（2）构建哈夫曼树：通过合并权值最小的两个节点，不断构建新的节点，直到所有节点合并为一棵树。
2. 哈夫曼编码（1）遍历哈夫曼树：从根节点开始，按照左子树为0、右子树为1的规则，记录每个叶子节点的路径。
（2）生成编码：将遍历过程中记录的路径转换为二进制编码，即为哈夫曼编码。
3. 哈夫曼解码（1）读取编码：将编码字符串按照二进制位读取。
（2）遍历哈夫曼树：从根节点开始，根据读取的二进制位，在哈夫曼树中寻找对应的节点。
（3）输出解码结果：当找到叶子节点时，输出对应的字符，并继续读取编码字符串。
三、实训过程1. 准备工作（1）创建一个Java项目，命名为“HuffmanCoding”。
（2）在项目中创建以下三个类：- HuffmanNode：用于存储哈夫曼树的节点信息；- HuffmanTree：用于构建哈夫曼树、生成编码和解码；- Main：用于实现主函数，接收用户输入并调用HuffmanTree类进行编码和解码。
2. 编写代码（1）HuffmanNode类：```javapublic class HuffmanNode {private char data;private int weight;private HuffmanNode left;private HuffmanNode right;public HuffmanNode(char data, int weight) {this.data = data;this.weight = weight;}}```（2）HuffmanTree类：```javaimport java.util.PriorityQueue;public class HuffmanTree {private HuffmanNode root;public HuffmanNode buildHuffmanTree(char[] data, int[] weight) {// 创建优先队列，用于存储叶子节点PriorityQueue<HuffmanNode> queue = new PriorityQueue<>();for (int i = 0; i < data.length; i++) {HuffmanNode node = new HuffmanNode(data[i], weight[i]);queue.offer(node);}// 构建哈夫曼树while (queue.size() > 1) {HuffmanNode left = queue.poll();HuffmanNode right = queue.poll();HuffmanNode parent = new HuffmanNode('\0', left.weight + right.weight);parent.left = left;parent.right = right;queue.offer(parent);}root = queue.poll();return root;}public String generateCode(HuffmanNode node, String code) {if (node == null) {return "";}if (node.left == null && node.right == null) {return code;}generateCode(node.left, code + "0");generateCode(node.right, code + "1");return code;}public String decode(String code) {StringBuilder result = new StringBuilder();HuffmanNode node = root;for (int i = 0; i < code.length(); i++) {if (code.charAt(i) == '0') {node = node.left;} else {node = node.right;}if (node.left == null && node.right == null) { result.append(node.data);node = root;}}return result.toString();}}```（3）Main类：```javaimport java.util.Scanner;public class Main {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("请输入字符串：");String input = scanner.nextLine();System.out.println("请输入字符及其权值（例如：a 2 b 3 c 5）："); String[] dataWeight = scanner.nextLine().split(" ");char[] data = new char[dataWeight.length / 2];int[] weight = new int[dataWeight.length / 2];for (int i = 0; i < dataWeight.length; i += 2) {data[i / 2] = dataWeight[i].charAt(0);weight[i / 2] = Integer.parseInt(dataWeight[i + 1]);}HuffmanTree huffmanTree = new HuffmanTree();HuffmanNode root = huffmanTree.buildHuffmanTree(data, weight); String code = huffmanTree.generateCode(root, "");System.out.println("编码结果：" + code);String decoded = huffmanTree.decode(code);System.out.println("解码结果：" + decoded);scanner.close();}}```3. 运行程序（1）编译并运行Main类，输入字符串和字符及其权值。
数据结构哈夫曼编码实验报告
数据结构哈夫曼编码实验报告【正文】1.实验目的本实验旨在研究哈夫曼编码的原理和实现方法，通过实验验证哈夫曼编码在数据压缩中的有效性，并分析其应用场景和优缺点。
2.实验原理2.1 哈夫曼编码哈夫曼编码是一种无损数据压缩算法，通过根据字符出现的频率构建一颗哈夫曼树，将频率较高的字符用较短的编码表示，频率较低的字符用较长的编码表示。
哈夫曼编码的编码表是唯一的，且能够实现前缀编码，即一个编码不是另一个编码的前缀。
2.2 构建哈夫曼树构建哈夫曼树的过程如下：1) 将每个字符及其频率作为一个节点，构建一个节点集合。
2) 每次从节点集合中选择出现频率最低的两个节点，构建一个新节点，并将这两个节点从集合中删除。
3) 将新节点加入节点集合。
4) 重复以上步骤，直到节点集合中只有一个节点，这个节点就是哈夫曼树的根节点。
2.3 编码过程根据哈夫曼树，对每个字符进行编码：1) 从根节点开始，根据左子树为0，右子树为1的规则，将编码依次加入编码表。
2) 对于每个字符，根据编码表获取其编码。
3) 将编码存储起来，得到最终的编码序列。
3.实验步骤3.1 数据读取与统计从输入文件中读取字符序列，并统计各个字符的频率。
3.2 构建哈夫曼树根据字符频率构建哈夫曼树。
3.3 构建编码表根据哈夫曼树，构建每个字符的编码表。
3.4 进行编码根据编码表，对输入的字符序列进行编码。
3.5 进行解码根据哈夫曼树，对编码后的序列进行解码。
4.实验结果与分析4.1 压缩率分析计算原始数据和压缩后数据的比值，分析压缩率。
4.2 编码效率分析测试编码过程所需时间，分析编码效率。
4.3 解码效率分析测试解码过程所需时间，分析解码效率。
4.4 应用场景分析分析哈夫曼编码在实际应用中的优势和适用场景。
5.结论通过本次实验，我们深入了解了哈夫曼编码的原理和实现方法，实践了哈夫曼编码的过程，并对其在数据压缩中的有效性进行了验证。
实验结果表明，哈夫曼编码能够实现较高的压缩率和较高的编解码效率。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
哈夫曼编码解码实验
1.实验要求
掌握二叉树的相关概念
掌握构造哈夫曼树，进行哈夫曼编码。
对编码内容通过哈夫曼树进行解码。
2.实验内容
通过二叉树构造哈夫曼树，并用哈夫曼树对读取的txt文件进行哈夫曼编码。
编码完成后通过哈夫曼树进行解码。
#include<stdio.h>
#include<string.h>
#define MAX 100
//定义哈夫曼树的存储结构
typedef struct
{
char data;
int weight;
int parent;
int lch;
int rch;
}HuffNode;
//定义哈夫曼编码的存储结构
typedef struct
{
char bit[MAX];
int start;
}HuffCode;
HuffNode ht[2*MAX];
HuffCode hcd[MAX];
int Coun[127]={0};
int n;
char s1[200000];
char text[5000];
//构造哈夫曼树
void HuffmanTree()
{
int i,j,k,left,right,min1,min2;
//printf("输入叶子的节点数：");
//scanf("%d",&n);
printf("字符数量=%d\n",n);
for(i=1;i<=2*n-1;i++)
{
ht[i].parent=ht[i].lch=ht[i].rch=0;
j=0;
for(i=1;i<=n;i++)
{
/*getchar();
printf("输入第%d个叶子节点的值：",i);
scanf("%c",&ht[i].data);
printf("输入该节点的权值：");
scanf("%d",&ht[i].weight);
*/
for(;j<127;j++)
{
if(Coun[j]!=0)
{
ht[i].data=j;
//printf("%c",ht[i].data);
ht[i].weight=Coun[j];
//printf("%d",ht[i].weight);
break;
}
}
j++;
}
printf("\n");
for(i=1;i<=n;i++)
printf("%c",ht[i].data);
}
printf("\n");
for(i=n+1;i<=2*n-1;i++)
{//在前n个结点中选取权值最小的两个结点构成一颗二叉树
min1=min2=10000;//为min1和min2设置一个比所有权值都大的值
left=right=0;
for(k=1;k<=i-1;k++)
{
if(ht[k].parent==0)//若是根结点
//令min1和min2为最小的两个权值，left和right 为权值最小的两个结点位置
if(ht[k].weight<min1)
{
min2=min1;
right=left;
min1=ht[k].weight;
left=k;
}
else if (ht[k].weight<min2)
{
min2=ht[k].weight;
right=k;
}
}
ht[left].parent=i;
ht[right].parent=i;
ht[i].weight=ht[left].weight+ht[right].weight;
ht[i].lch=left;
ht[i].rch =right;
}
}
//构造哈夫曼编码
void HuffmanCode()
{
int i,c,k,f;
HuffCode cd;
for(i=1;i<=n;i++)
{
cd.start=n;
c=i;
f=ht[i].parent;
while(f!=0)
{
if(ht[f].lch==c)
cd.bit[cd.start]='0';
else
cd.bit[cd.start]='1';
cd.start--;
c=f;
f=ht[f].parent;
}
hcd[i]=cd;
}
printf("输出哈夫曼编码：\n");
for(i=1;i<=n;i++)
{
printf("%c:",ht[i].data);
for(k=hcd[i].start+1;k<=n;k++)
printf("%c",hcd[i].bit[k]);
printf("\n");
}
}
//对字母进行编码
void Code()//将字符与相应的哈夫曼编码进行匹配，输出编码结果{
int i=0,j,k,h=0;
while(text[i]!='\0')
for(j=1;j<=n;j++)
{
if(text[i]==ht[j].data)
{
for(k=hcd[j].start+1;k<=n;k++)
{
s1[h]=hcd[j].bit[k];
h++;
}
break;
}
}
i++;
}
//printf("编码\n");
//puts(s1);
//printf("\n");
}
void HuffmanDecode()
{
printf("解码\n");
int len,i,f;
char C;
//char S[MAXCODE];
//scanf("%s",S);//使用gets()直接跳过
len=strlen(s1);
printf("s1:%d\n",len);
f=2*n-1;
for(i=0;i<len;i++)
{
if(s1[i]=='0')
{
f=ht[f].lch;
if(ht[f].lch==0&&ht[f].rch==0)
{
C=ht[f].data;
printf("%c",C);
f=2*n-1;
}
}
else if(s1[i]=='1')
{
f=ht[f].rch;
if(ht[f].lch==0&&ht[f].rch==0)
{
C=ht[f].data;
printf("%c",C);
f=2*n-1;
}
}
}
printf("\n");
}
//统计字母个数及其权值
void Count()
{
int i,j,m;
n=0;
i=0;
//printf("请仅输入小写字母\n");//例程本省存在一个BUG，只输入一个字母不能进行编码（并未解决）
//scanf("%s",s);
while(text[i]!='\0')//使用ASCII码表进行统计
{
m=text[i];
//printf("%d\n",m);
Coun[m]++;
i++;
}
for(j=0;j<127;j++)
{
if(Coun[j]!=0)
n++;
}
}
//mark Code
void main()
{
int l=0;
FILE *fp;
fp=fopen("text.txt","r");
if(fp==NULL)
{
printf("文件打开失败\n");
while(1);
}
while(!feof(fp))
{
text[l] = fgetc(fp);
l++;
}
printf("输入文本\n");
printf("%s\n",text);
fclose(fp);
Count();
HuffmanTree();
HuffmanCode();
Code();
HuffmanDecode();
}
文本文件
文本输入
进行哈夫曼编码
对文本进行编码
输出解码结果
3.实验总结
通过本次实验，对二叉树的应用有了相应的了解，掌握了如何构造哈夫曼编码，如何对编码结果进行解码。
最重要的是学会了如何思考着去解决问题，以及代码的调试。
（注：可编辑下载，若有不当之处，请指正，谢谢!）。