北邮数据结构实验报告
北邮数据结构第四次实验排序(MFC实现)
2011级数据结构实验报告实验名称：实验四——排序(MFC实现)学生姓名：班级：发邮件到1017431192@附赠MFC源程序一份班内序号：北邮学生你懂得…..学号：日期：1．实验要求实验目的：通过选择下面两个题目之一，学习、实现、对比各种排序算法，掌握各种排序算法的优劣，以及各种算法使用的情况。
实验内容：使用简单数组实现下面各种排序算法，并进行比较。
排序算法：1、插入排序2、希尔排序3、冒泡排序4、快速排序5、简单选择排序6、堆排序7、归并排序8、基数排序（选作）9、其他要求：1、测试数据分成三类：正序、逆序、随机数据2、对于这三类数据，比较上述排序算法中关键字的比较次数和移动次数（其中关键字交换计为3次移动）。
3、对于这三类数据，比较上述排序算法中不同算法的执行时间，精确到微秒（选作）4、对2和3的结果进行分析，验证上述各种算法的时间复杂度编写测试main()函数测试线性表的正确性。
2. 程序分析2.1 存储结构使用最简单的一维数组存储待排序的数据。
共使用两个数组，一个用来存储原始数据，一个用来存储待排序数据。
每次排序完毕，用原始数据更新一次待排序数据，保证每一次都对同一组数据排序。
2.2 关键算法分析1.直接插入的改进：在一般的直接插入中，关键码每移动一次就需要比较一次。
在移动的方面，优化是比较困难的，因为对静态线性表的插入必然要带来大量的移动。
但是，我们可以在比较上进行一些优化。
在查找技术一张曾学过的“折半查找法”，在这里就可以照葫芦画瓢地运用。
一趟排序的伪代码如下：1.如果该元素大于处于其左侧相邻的元素则跳过该元素；2.low=0，high=i；3.循环直至low==high3.1 mid=(low+high)/2；3.2如果当前元素大于中值high=mid；3.3否则low=mid+1；4.当前元素赋值给临时变量；5.将有序区中处于low位置及其右侧的元素右移；6.临时变量置于low位置简单说一下这里的折半查找与一般查找算法的区别。
北邮数据结构平衡二叉树报告概论
数据结构实验报告实验名称：平衡二叉树1.实验目的和内容根据平衡二叉树的抽象数据类型的定义，使用二叉链表实现一个平衡二叉树。
二叉树的基本功能：1、平衡二叉树的建立2、平衡二叉树的查找3、平衡二叉树的插入4、平衡二叉树的删除5、平衡二叉树的销毁6、其他：自定义操作编写测试main()函数测试平衡二叉树的正确性。
2. 程序分析2.1 存储结构struct node{int key; //值int height; //这个结点的父节点在这枝最长路径上的结点个数node *left; //左孩子指针node *right; //右孩子指针node(int k){ key = k; left = right = 0; height = 1; } //构造函数};2.2 程序流程2.3 关键算法分析（由于函数过多，在此只挑选部分重要函数）算法1：void AVL_Tree::left_rotate(node *&x)[1] 算法功能：对 R-R型进行调整[2] 算法基本思想：将结点右孩子进行逆时针旋转[3] 算法空间、时间复杂度分析：都为0（1）[4] 代码逻辑node *y = x->right; y为x的右孩子x->right = y->left; 将y的左孩子赋给x的右孩子 y->left = x; x变为y的左孩子fixheight(x); 修正x，y的height值fixheight(y);x = y; 使x的父节点指向y 算法2：void A VL_Tree::right_rotate(node *&x)[1] 算法功能：对L-L型进行调整[2] 算法基本思想：将左孩子进行顺时针旋转[3] 算法空间、时间复杂度分析：都为0（1）[4] 代码逻辑node *y = x->left; //y为x的左孩子 x->left = y->right; y的右孩子赋给x的左孩子y->right = x; x变为y的右孩子fixheight(x); 修正x和y的height值fixheight(y);x = y; 使x的父节点指向y算法3：node*& A VL_Tree::balance(node *&p)[1] 算法功能：对给定结点进行平衡操作[2] 算法基本思想：通过平衡因子判断属于哪种情况，再依照情况进行平衡[3] 算法空间、时间复杂度分析：没有递归和循环，都为O（1）[4] 代码逻辑fixheight(p); //修正P的height值if (bfactor(p) == 2) 平衡因子为2，为L-？型if (bfactor(p->left) < 0) P的左孩子平衡因子<0时，为L-R型，执行left_rotate(p->left); 相关平衡操作，若>0，为L-L型。
北邮-数据结构-哈夫曼树报告
数据结构欧阳学文实验报告实验名称：哈夫曼树学生姓名：袁普班级：211125班班内序号：14号学号：210681日期：12月1.实验目的和内容利用二叉树结构实现哈夫曼编/解码器。
基本要求：1、初始化(Init)：能够对输入的任意长度的字符串s进行统计，统计每个字符的频度，并建立哈夫曼树2、建立编码表(CreateTable)：利用已经建好的哈夫曼树进行编码，并将每个字符的编码输出。
3、编码(Encoding)：根据编码表对输入的字符串进行编码，并将编码后的字符串输出。
4、译码(Decoding)：利用已经建好的哈夫曼树对编码后的字符串进行译码，并输出译码结果。
5、打印(Print)：以直观的方式打印哈夫曼树（选作）6、计算输入的字符串编码前和编码后的长度，并进行分析，讨论赫夫曼编码的压缩效果。
7、可采用二进制编码方式（选作）测试数据：I love data Structure, I love Computer。
I will try my best to study data Structure.提示：1、用户界面可以设计为“菜单”方式：能够进行交互。
2、根据输入的字符串中每个字符出现的次数统计频度，对没有出现的字符一律不用编码2. 程序分析2.1 存储结构用struct结构类型来实现存储树的结点类型struct HNode{int weight; //权值int parent; //父节点int lchild; //左孩子int rchild; //右孩子};struct HCode //实现编码的结构类型{char data; //被编码的字符char code[100]; //字符对应的哈夫曼编码};2.2 程序流程2.3算法1：void Huffman::Count()[1] 算法功能：对出现字符的和出现字符的统计，构建权值结点，初始化编码表[2] 算法基本思想：对输入字符一个一个的统计，并统计出现次数，构建权值数组，[3] 算法空间、时间复杂度分析：空间复杂度O（1），要遍历一遍字符串，时间复杂度O（n）[4] 代码逻辑：leaf=0; //初始化叶子节点个数int i,j=0;int s[128]={0}; 用于存储出现的字符for(i=0;str[i]!='\0';i++) 遍历输入的字符串s[(int)str[i]]++; 统计每个字符出现次数for(i=0;i<128;i++)if(s[i]!=0){data[j]=(char)i; 给编码表的字符赋值weight[j]=s[i]; 构建权值数组j++;}leaf=j; //叶子节点个数即字符个数for(i=0;i<leaf;i++)cout<<data[i]<<"的权值为："<<weight[i]<<endl;算法2：void Init();[1] 算法功能：构建哈弗曼树[2] 算法基本思想：根据哈夫曼树构建要求，选取权值最小的两个结点结合，新结点加入数组，再继续选取最小的两个结点继续构建。
北邮程序实践实验报告(2篇)
第1篇一、实验目的本次实验旨在通过北邮程序实践，加深对编程基础知识的理解，提高编程能力和实践操作能力。
通过实验，使学生能够熟练运用编程语言进行实际问题求解，培养独立思考和团队协作能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发工具：PyCharm三、实验内容本次实验主要分为三个部分：数据结构、算法设计与分析、编程实践。
1. 数据结构（1）实验内容：实现线性表、栈、队列、链表、树等基本数据结构。
（2）实验步骤：步骤一：创建一个线性表类，实现线性表的基本操作，如插入、删除、查找等。
步骤二：创建一个栈类，实现栈的基本操作，如入栈、出栈、判断栈空等。
步骤三：创建一个队列类，实现队列的基本操作，如入队、出队、判断队列空等。
步骤四：创建一个链表类，实现链表的基本操作，如插入、删除、查找等。
步骤五：创建一个树类，实现树的基本操作，如创建树、遍历树、查找节点等。
（3）实验结果：通过实验，成功实现了线性表、栈、队列、链表、树等基本数据结构，并验证了其功能。
2. 算法设计与分析（1）实验内容：设计并分析排序算法、查找算法、递归算法等。
（2）实验步骤：步骤一：设计并实现冒泡排序、选择排序、插入排序等排序算法。
步骤二：设计并实现二分查找、线性查找等查找算法。
步骤三：设计并实现递归算法，如汉诺塔、斐波那契数列等。
（3）实验结果：通过实验，成功实现了冒泡排序、选择排序、插入排序、二分查找、线性查找、递归算法等，并分析了其时间复杂度和空间复杂度。
3. 编程实践（1）实验内容：利用所学编程知识，解决实际问题。
（2）实验步骤：步骤一：分析问题，确定算法和数据结构。
步骤二：编写代码，实现算法。
步骤三：调试代码，确保程序正确运行。
步骤四：优化代码，提高程序效率。
（3）实验结果：通过实验，成功解决了以下实际问题：1. 输入一个整数序列，输出最大值、最小值、平均值和方差。
2. 输入一个字符串，输出字符串的逆序。
北邮数据结构实验 第三次实验 排序剖析
数据结构实验报告1．实验要求(1)实验目的通过选择下面两个题目之一，学习、实现、对比各种排序算法，掌握各种排序算法的优劣，以及各种算法使用的情况。
(2)实验内容使用简单数组实现下面各种排序算法，并进行比较。
排序算法：1、插入排序2、希尔排序3、冒泡排序4、快速排序5、简单选择排序6、堆排序（选作）7、归并排序（选作）8、基数排序（选作）9、其他要求：1、测试数据分成三类：正序、逆序、随机数据2、对于这三类数据，比较上述排序算法中关键字的比较次数和移动次数（其中关键字交换计为3次移动）。
3、对于这三类数据，比较上述排序算法中不同算法的执行时间，精确到微秒（选作）4、对2和3的结果进行分析，验证上述各种算法的时间复杂度编写测试main()函数测试排序算法的正确性。
2. 程序分析2.1 存储结构顺序表:示意图：2.2 关键算法分析（1）测试数据的产生：正序、逆序、随机数据用两个数组实现乱序、顺序以及逆序数据的排序。
基本思想为：随机序列产生一个指定长度的乱序序列，然后通过memcpy()函数拷贝到第二个数组里，第二个数组作为乱序序列的保存数组，每次对第一个数组进行排序，之后拷贝第二个数组中的乱序序列到第一个数组，实现各次乱序排列。
只要算法正确（第一步可以检验），之后顺序排列只需反复对第一个数组进行操作即可，再后用第二个数组保存逆序数组，然后同样在每次排序之后复制第二数组存储的乱序序列到第一组，对第一组反复排序即可。
<1> pRandom1=new long int[Max+1];pRandom2=new long int[Max+1];<2> srand((unsigned)time(NULL)); for(int i = 1; i <= Max;i++ ) pRandom2[i]=rand();<3> memcpy(obj.pRandom1,obj.pRandom2,(Max+1)*sizeof(long int));（2）排序算法：<1>插入排序：依次将待排序的序列中的每一个记录插入到先前排序好的序列中，直到全部记录排序完毕。
北邮数据结构实验-约瑟夫环
北邮数据结构实验-约瑟夫环数据结构实验报告实验名称：实验1——约瑟夫环学生姓名：班级：班内序号：学号：日期：1．实验要求实验目的：通过利用循环链表实现约瑟夫问题的求解进行实现，掌握如下内容：1.熟悉C++语言的基本编程方法，掌握集成编译环境的调试方法2.学习指针、模板类、异常处理的使用3.掌握线性表的操作的实现方法4.学习使用线性表解决实际问题的能力实验内容：利用循环链表实现约瑟夫问题的求解。
约瑟夫问题如下：已知n个人（n>=1）围坐一圆桌周围，从1开始顺序编号。
从序号为1的人开始报数，顺时针数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规则重复下去，直到所有人全部出列。
请问最后一个出列的人的编号。
2. 程序分析2.1 存储结构首先构建结点的结构体，包括结点的编号number和指向后继元素的指针*next。
然后构建循环链表储存每一个结点。
2.2 关键算法分析1、关键算法：插入：用尾插法构建循环链表，建立一个尾指针r用来保存最后一个结点的地址，插入每一个节点后，r指向新插入的结点。
用for循环来给每一个结点的number赋值。
插入的步骤：1.建立新指针s；2.在for循环中给s赋值；3.将r指针指向s；4.修改尾指针r=s5.在全部结点插入后，将终端结点指向第一个指针，r->next=front->next。
约瑟夫环算法实现：1.因为每次循环都有一个人出列，最后只剩一个人，因此要进行n-1次循环，用for循环实现。
2.同时定义一个指针p=front->next，每次循环front和p均后移m-1个，使p指向每次循环的第m个人，front指向第m-1个人。
并输出出列的人的number，即p->number。
3.让front->next=p->next，删除p。
4.继续进行循环2、代码详细分析：约瑟夫环算法步骤：①定义一个指针p=front->next，每次循环front和p均后移m-1个，使p指向每次循环的第m个人，front指向第m-1个人。
北邮信通院数据结构实验报告三哈夫曼编码器.docx
北京邮电大学电信工程学院数据结构实验报告实验名称：实验三树——哈夫曼编/解码器学生姓名：班级：班内序号：学号：日期： 2014 年 12 月 11 日1．实验要求利用二叉树结构实现赫夫曼编/解码器。
基本要求：1、初始化 (Init) ：能够对输入的任意长度的字符串s 进行统计，统计每个字符的频度，并建立赫夫曼树2、建立编码表 (CreateTable)：利用已经建好的赫夫曼树进行编码，并将每个字符的编码输出。
3、编码 (Encoding)：根据编码表对输入的字符串进行编码，并将编码后的字符串输出。
4、译码 (Decoding)：利用已经建好的赫夫曼树对编码后的字符串进行译码，并输出译码结果。
5、打印 (Print)：以直观的方式打印赫夫曼树（选作）6、计算输入的字符串编码前和编码后的长度，并进行分析，讨论赫夫曼编码的压缩效果。
测试数据：I love data Structure, I love Computer。
I will try my best to study data Structure.提示：1、用户界面可以设计为“菜单”方式：能够进行交互。
2、根据输入的字符串中每个字符出现的次数统计频度，对没有出现的字符一律不用编码。
-2.程序分析2.1 存储结构Huffman 树给定一组具有确定权值的叶子结点，可以构造出不同的二叉树，其中带权路径长度最小的二叉树称为Huffman树，也叫做最优二叉树。
weight lchild rchild parent2-1-1-15-1-1-16-1-1-17-1-1-19-1-1-1weight lchild rchild parent 2-1-15 5-1-15 6-1-16 7-1-16 9-1-17 701713238165482967-12.2 关键算法分析（1）计算出现字符的权值利用 ASCII 码统计出现字符的次数，再将未出现的字符进行筛选，将出现的字符及頻数存储在数组a[] 中。
北邮信通院数据结构实验报告三哈夫曼编码器
数据结构真验报告之阳早格格创做真验称呼：真验三树——哈妇曼编/解码器教死姓名：班级：班内序号：教号：日期： 2014年12月11日1．真验央供利用二叉树结构真止赫妇曼编/解码器.基础央供：1、初初化(Init)：不妨对于输进的任性少度的字符串s举止统计，统计每个字符的频度，并建坐赫妇曼树2、建坐编码表(CreateTable)：利用已经建佳的赫妇曼树举止编码，并将每个字符的编码输出.3、编码(Encoding)：根据编码表对于输进的字符串举止编码，并将编码后的字符串输出.4、译码(Decoding)：利用已经建佳的赫妇曼树对于编码后的字符串举止译码，并输出译码截止.5、挨印(Print)：以曲瞅的办法挨印赫妇曼树（选做）6、估计输进的字符串编码前战编码后的少度，并举止分解，计划赫妇曼编码的压缩效验.尝试数据：I love data Structure, I love Computer.I will try my best to study data Structure.提示：1、用户界里不妨安排为“菜单”办法：不妨举止接互.2、根据输进的字符串中每个字符出现的次数统计频度，对于不出现的字符一律不必编码.2. 步调分解2.1 保存结构Huffman树给定一组具备决定权值的叶子结面，不妨构制出分歧的二叉树，其中戴权路径少度最小的二叉树称为Huffman树，也喊干最劣二叉树.weight lchild rchildparent 2-1-1-15-1-1-16-1-1-17-1-1-19-1-1-1weight lchild rchild parent2-1-155-1-156-1-167-1-169-1-17701713238165482967-1（1）估计出现字符的权值利用ASCII码统计出现字符的次数，再将已出现的字符举止筛选，将出现的字符及頻数保存正在数组a[]中.void Huffman::Init(){int nNum[256]= {0}; //记录每一个字符出现的次数int ch = cin.get();int i=0;while((ch!='\r') && (ch!='\n')){nNum[ch]++; //统计字符出现的次数str[i++] = ch; //记录本初字符串ch = cin.get(); //读与下一个字符}str[i]='\0';n = 0;for ( i=0;i<256;i++){if (nNum[i]>0) //若nNum[i]==0，字符已出现{l[n] = (char)i;a[n] = nNum[i];n++;}}}时间搀纯度为O（1）；（2）创制哈妇曼树：算法历程：Huffman树采与程序保存---数组；数组的前n个结面保存叶子结面，而后是分收结面，末尾是根结面；最先初初化叶子结面元素—循环真止；以循环结构，真止分收结面的合成，合成准则依照huffman树形成准则举止.闭键面：采用最小战次小结面合成.void Huffman::CreateHTree(){HTree = new HNode [2*n-1]; //根据权沉数组a[0..n-1] 初初化Huffman树for (int j = 0; j < n; j++){HTree[j].weight = a[j];HTree[j].LChild = HTree[j].RChild = HTree[j].parent = -1;}int x,y;for (int i = n; i < 2*n-1; i++) //启初建Huffman树{SelectMin( HTree, i, x, y); //从1~i中选出二个权值最小的结面HTree[x].parent = HTree[y].parent = i;HTree[i].weight = HTree[x].weight+ HTree[y].weight;HTree[i].LChild = x;HTree[i].RChild = y;HTree[i].parent = -1;}}时间搀纯度为O(n2)void Huffman::SelectMin( HNode *hTree,int n, int &i1, int &i2 ){int i;//找一个比较值的起初值for(i=0; i<n; i++) //找i1{ if(hTree[i].parent==-1 ){ i1=i; break; }}i++;for( ; i<n; i++) //找i2{ if(hTree[i].parent==-1 ){ i2=i; break; }}if(hTree[i1].weight>hTree[i2].weight) //i1指背最小的{ int j=i2; i2=i1; i1 = j; }//启初找最小的二个i++;for( ; i<n; i++){ if(hTree[i].parent==-1&& hTree[i].weight < hTree[i1].weight ){ i2=i1; i1 = i; }else if( hTree[i].parent==-1&& hTree[i].weight < hTree[i2].weight){ i2=i; }}}时间搀纯度为O(n)(3)创制编码表算法历程：从叶子到根---自底进与最先定义码表保存空间；循环对于n个叶子结面自底进与回溯到根，记下道路的安排闭系，产死编码的顺序串；将各个叶子结面对于应的顺序串反序即可.void Huffman::CreateCodeTable(){HCodeTable = new HCode[n]; //死成编码表for (int i=0;i<n;i++){HCodeTable[i].data = l[i];int child = i; //孩子结面编号int parent = HTree[i].parent; //目前结面的女结面编号int k=0;while(parent!=-1){if (child==HTree[parent].LChild) //左孩子标‘0’HCodeTable[i].code[k] = '0';elseHCodeTable[i].code[k] = '1' ; //左孩子标‘1’k++;child = parent; //迭代parent = HTree[child].parent;}HCodeTable[i].code[k] = '\0';Reverse(HCodeTable[i].code); //将编码字符顺置}}时间搀纯度为O(n)(4)死成编码串将输进的字符串的每一个字符与编码表比较void Huffman::Encode(char *d)//编码，d为编码后的字符串{char *s = str;while(*s!='\0'){for (int i=0;i<n;i++)if (*s == HCodeTable[i].data ){strcat(d, HCodeTable[i].code);break;}s++;}}时间搀纯度为O(n)（5）解码:算法历程：从根到叶子---自顶背下鉴于huffman树保存数组，从根结面启初，依据输进待解码串s中码字0或者1，分别背左或者左追踪至叶子结面，叶子结面对于应的字符（睹码表），即为解码得到的字符；只消s串为中断，沉复上述历程void Huffman::Decode(char* s, char *d) //解码，s为编码串，d为解码后的字符串{while(*s!='\0'){int parent = 2*n-2; //根结面正在HTree中的下标while (HTree[parent].LChild!=-1) //如果不是叶子结面{if (*s=='0')parent = HTree[parent].LChild;elseparent = HTree[parent].RChild;s++;}*d = HCodeTable[parent].data;d++;}}时间搀纯度为O（n）（1）哈妇曼树的输出是以凸进表示法去真止的，简曲算法如下：void Huffman::Print(int i, int m){if (HTree[i].LChild == -1)cout<<setfill(' ')<<setw(m+1)<<l[i]<<setfill('-')<<setw(10-m)<<'\n';else{cout<<setfill('')<<setw(m+1)<<HTree[i].weight<<setfill('-')<<setw(10-m)<<'\n';Print(HTree[i].LChild,m+1);Print(HTree[i].RChild,m+1);}}（2）统计字符頻数时，利用字符的ASCII 码举止计数统计，调用了cin.get()函数3. 步调运止步调框图：步调源代码： #include <iostream>#include <iomanip>using namespace std;struct HNode{int weight; //结面权值int parent; //单亲指针int LChild; //左孩子指针int RChild ;//左孩子指针 };struct HCode{char data;启初输进要编码的字符串 统计字符頻数 死成哈妇曼树 创制编码表 死成编码串 解码中断char code[100];};class Huffman{private:HNode* HTree; //Huffman树HCode* HCodeTable; //Huffman编码表char str[1024]; //输进的本初字符串char l[256]; //叶子节面对于应的字符int a[256]; //记录每个出现的字符的个数public:int n; //叶子节面数void Init(); //初初化void CreateHTree(); //创制huffman树 void CreateCodeTable(); //创制编码表void PrintTable();void Encode(char *d); //编码void Decode(char *s, char *d); //解码void Print(int i,int m); //挨印Huffman树void SelectMin( HNode *hTree,int n, int &i1, int &i2);//找出最小的二个权值void Reverse(char* s); //顺序void Compare(char*d); //比较压缩大小 ~ Huffman(); //析构};void Huffman::Init(){int nNum[256]= {0}; //记录每一个字符出现的次数int ch = cin.get();int i=0;while((ch!='\r') && (ch!='\n')){nNum[ch]++; //统计字符出现的次数str[i++] = ch; //记录本初字符串ch = cin.get(); //读与下一个字符}str[i]='\0';n = 0;for ( i=0;i<256;i++){if (nNum[i]>0) //若nNum[i]==0，字符已出现{l[n] = (char)i;a[n] = nNum[i];n++;}}}void Huffman::CreateHTree(){HTree = new HNode [2*n-1]; //根据权沉数组a[0..n-1] 初初化Huffman树for (int j = 0; j < n; j++){HTree[j].weight = a[j];HTree[j].LChild = HTree[j].RChild = HTree[j].parent = -1;}int x,y;for (int i = n; i < 2*n-1; i++) //启初建Huffman树{SelectMin( HTree, i, x, y); //从1~i中选出二个权值最小的结面HTree[x].parent = HTree[y].parent = i;HTree[i].weight = HTree[x].weight+ HTree[y].weight;HTree[i].LChild = x;HTree[i].RChild = y;HTree[i].parent = -1;}}void Huffman::SelectMin( HNode *hTree,int n, int &i1, int &i2 ){int i;//找一个比较值的起初值for(i=0; i<n; i++) //找i1{ if(hTree[i].parent==-1 ){ i1=i; break; }}i++;for( ; i<n; i++) //找i2{ if(hTree[i].parent==-1 ){ i2=i; break; }}if(hTree[i1].weight>hTree[i2].weight) //i1指背最小的{ int j=i2; i2=i1; i1 = j; }//启初找最小的二个i++;for( ; i<n; i++){ if(hTree[i].parent==-1&& hTree[i].weight < hTree[i1].weight ){ i2=i1; i1 = i; }else if( hTree[i].parent==-1&& hTree[i].weight < hTree[i2].weight){ i2=i; }}}void Huffman::Print(int i, int m){if (HTree[i].LChild == -1)cout<<setfill('')<<setw(m+1)<<l[i]<<setfill('-')<<setw(10-m)<<'\n';else{cout<<setfill('')<<setw(m+1)<<HTree[i].weight<<setfill('-')<<setw(10-m)<<'\n';Print(HTree[i].LChild,m+1);Print(HTree[i].RChild,m+1);}}void Huffman::CreateCodeTable(){HCodeTable = new HCode[n]; //死成编码表for (int i=0;i<n;i++){HCodeTable[i].data = l[i];int child = i; //孩子结面编号int parent = HTree[i].parent; //目前结面的女结面编号int k=0;while(parent!=-1){if (child==HTree[parent].LChild) //左孩子标‘0’HCodeTable[i].code[k] = '0';elseHCodeTable[i].code[k] = '1' ; //左孩子标‘1’k++;child = parent; //迭代parent = HTree[child].parent;}HCodeTable[i].code[k] = '\0';Reverse(HCodeTable[i].code); //将编码字符顺置}}void Huffman::PrintTable(){for (int i=0;i<n;i++)cout<<HCodeTable[i].data<<'\t'<<HCodeTable [i].code<<endl;}void Huffman::Encode(char *d)//编码，d为编码后的字符串{char *s = str;while(*s!='\0'){for (int i=0;i<n;i++)if (*s == HCodeTable[i].data ){strcat(d, HCodeTable[i].code);break;}s++;}}void Huffman::Decode(char* s, char *d) //解码，s为编码串，d为解码后的字符串{while(*s!='\0'){int parent = 2*n-2; //根结面正在HTree中的下标while (HTree[parent].LChild!=-1) //如果不是叶子结面{if (*s=='0')parent = HTree[parent].LChild;elseparent = HTree[parent].RChild;s++;}*d = HCodeTable[parent].data;d++;}}void Huffman::Reverse(char* s)//换序{char ch;int len = strlen(s);for (int i=0;i<len/2;i++){ch = s[i];s[i] = s[len-i-1];s[len-i-1] = ch;}}void Huffman::Compare(char*d)//比较压缩大小{cout<<"编码前："<<strlen(str)*8<<"bit"<<endl;cout<<"编码后："<<strlen(d)<<"bit"<<endl; }Huffman::~ Huffman()//析构函数{delete []HTree;delete []HCodeTable;}void main(){Huffman HFCode;char d[1024]={0};char s[1024]={0};cout<<"请输进要编码的字符串：";HFCode.Init();HFCode.CreateHTree();HFCode.CreateCodeTable();HFCode.Encode(d);HFCode.Decode(d,s);int m;cout<<"欢迎使用\n"<<"1.挨印哈妇曼树\n"<<"2.挨印哈妇曼编码表\n"<<"3.挨印编码\n"<<"4.挨印解码\n"<<"5.压缩比"<<endl;while(1){cin>>m;switch(m){case 1:{HFCode.Print(2*HFCode.n-2,1);break;}case 2:{HFCode.PrintTable( );break;}case 3:{cout<<"编码截止："<<d<<endl;break;}case 4:{cout<<"解码截止："<<s<<endl;break;}case 5:{pare(d);}}}}运止截止：4. 归纳正在编程时，最启初正在字符统计时出现了空格无法统计的问题，厥后用cin.get()函数举止统计.末尾由于有一些字符不出现过，所以还需要举止筛选.正在输出哈妇曼树时，采与了凸进函数法举止输出，越收曲瞅.创制编码表时，启初是自下到上的举止遍历，所以末尾还需要举止顺序，产死最后的编码表.创制编码树的时间，不精确使用指针的传播，截止出现了很多问题，百般内存考察过失，末尾通过细细天重新到尾查看，创制了是正在形式参数的场合出现了过失，正在获与二个最小权值的结面的时间该当用引用，改过去之后过失不了.挨印赫妇曼树是最易的部分，一启初不找到符合的办法，出现了很多问题，末尾采与凸进表示挨印的要领，从最左边的结面启初一止一止的挨印，末尾问题也能办理了.调试时，出现的问题是正在举止编码时循环出现了过失，引导运止后编码变少，通过建改问题得以办理.通过哈妇曼编码的步调安排，越收深进的教习了哈妇曼树编码的思维，相识了不等少编码的思维，共时也通过试验明黑了编码器的本理，正在编码历程中，里对于出现的问题，也教习了字符串的相闭函数的使用，越收相识树的保存结构，受益匪浅.。
北邮信通院数据结构实验报告三哈夫曼编码器之欧阳引擎创编
数据结构实验报告欧阳引擎（2021.01.01）实验名称：实验三树——哈夫曼编/解码器学生姓名：班级：班内序号：学号：日期： 2014年12月11日1．实验要求利用二叉树结构实现赫夫曼编/解码器。
基本要求：1、初始化(Init)：能够对输入的任意长度的字符串s进行统计，统计每个字符的频度，并建立赫夫曼树2、建立编码表(CreateTable)：利用已经建好的赫夫曼树进行编码，并将每个字符的编码输出。
3、编码(Encoding)：根据编码表对输入的字符串进行编码，并将编码后的字符串输出。
4、译码(Decoding)：利用已经建好的赫夫曼树对编码后的字符串进行译码，并输出译码结果。
5、打印(Print)：以直观的方式打印赫夫曼树（选作）6、计算输入的字符串编码前和编码后的长度，并进行分析，讨论赫夫曼编码的压缩效果。
测试数据：I love data Structure, I love Computer。
I will try my best to study data Structure.提示：1、用户界面可以设计为“菜单”方式：能够进行交互。
2、根据输入的字符串中每个字符出现的次数统计频度，对没有出现的字符一律不用编码。
2. 程序分析2.1 存储结构Huffman树给定一组具有确定权值的叶子结点，可以构造出不同的二叉树，其中带权路径长度最小的二叉树称为Huffman树，也叫做最优二叉树。
weight lchild rchildparent 2-1-1-15-1-1-1 6-1-1-1 7-1-1-1 9-1-1-1weight lchild rchild parent2-1-155-1-156-1-167-1-169-1-17701713238165482967-12.2关键算法分析（1）计算出现字符的权值利用ASCII码统计出现字符的次数，再将未出现的字符进行筛选，将出现的字符及頻数存储在数组a[]中。
北邮信通院数据结构实验二--八皇后问题实验报告(内附源代码完整版)
2.1存储结构
存储结构：栈（递归）
2.2关键算法分析
递归调用摆放皇后
1、关键算法伪代码：
（1）.如果输入的row大于皇后的数量，则输出皇后的位置
（2）否则col从0开始递增
(3)检测（row，col）上的点是否符合条件，不符合则col自增，符合则转到下一个皇后的排列
2、代码详细分析：
void SeqStack::PlaceQueen(int row) //摆放皇后
{
for (int col=0;col< n;col++) //遍历0~7，
{
Push(col);
if (Check()) //判断摆放皇后的位置是否合适
{
if (row< n-1) //若还没有放到最后一个，则进行下一个皇后的放置
PlaceQueen(row+1);
else
{
num++; //计数器加1
{
if(top>= m-1) throw "上溢";
top++; //栈顶指针上移
data[top]=x;
}
void SeqStack::Pop() //出栈操作
{
if(Empty()) throw "下溢";
top--; //栈顶指针下移
}
void SeqStack::PlaceQue计放置八皇后，只要修改输入的N，便可显示其他情况的结果。
Print(n); //打印成功的坐标点
}
}
Pop(); //若不符合条件则出栈
}
}
bool SeqStack::Empty()
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
北邮数据结构实验报告
北邮数据结构实验报告
一、引言
数据结构是计算机科学中的重要基础知识，对于计算机程序的设计和性能优化
起着至关重要的作用。
本报告旨在总结北邮数据结构实验的相关内容，包括实
验目的、实验设计、实验过程和实验结果等。
二、实验目的
本次实验旨在通过实践操作，加深对数据结构的理解和应用能力。
具体目的如下：
1. 掌握线性表、栈和队列等基本数据结构的实现方法；
2. 熟悉二叉树、图等非线性数据结构的构建和遍历算法；
3. 学会使用递归和非递归算法解决实际问题；
4. 培养编程实践能力和团队合作意识。
三、实验设计
本次实验包括以下几个部分：
1. 线性表实验：设计一个线性表类，实现线性表的基本操作，如插入、删除和
查找等。
通过实验，了解线性表的顺序存储和链式存储结构的特点和应用场景。
2. 栈和队列实验：设计栈和队列类，实现栈和队列的基本操作，如入栈、出栈、入队和出队等。
通过实验，掌握栈和队列的应用，如括号匹配、迷宫求解等。
3. 二叉树实验：设计二叉树类，实现二叉树的创建、遍历和查找等操作。
通过
实验，熟悉二叉树的前序、中序和后序遍历算法，并了解二叉树的应用，如表
达式求值等。
4. 图实验：设计图类，实现图的创建、遍历和最短路径等操作。
通过实验，掌
握图的邻接矩阵和邻接表表示方法，并了解图的深度优先搜索和广度优先搜索
算法。
四、实验过程
1. 线性表实验：根据实验要求，首先选择线性表的存储结构，然后设计线性表类，实现插入、删除和查找等基本操作。
在实验过程中，遇到了一些问题，如
边界条件的处理和内存管理等，通过团队合作，最终解决了这些问题。
2. 栈和队列实验：根据实验要求，设计栈和队列类，实现入栈、出栈、入队和
出队等基本操作。
在实验过程中，我们发现了栈和队列在实际应用中的重要性，如括号匹配和迷宫求解等，通过实验加深了对栈和队列的理解。
3. 二叉树实验：根据实验要求，设计二叉树类，实现二叉树的创建、遍历和查
找等操作。
在实验过程中，我们发现了二叉树在表达式求值和排序等方面的应用，通过实验加深了对二叉树的理解。
4. 图实验：根据实验要求，设计图类，实现图的创建、遍历和最短路径等操作。
在实验过程中，我们发现了图在社交网络和路线规划等方面的应用，通过实验
加深了对图的理解。
五、实验结果
通过实验，我们成功设计和实现了线性表、栈、队列、二叉树和图等数据结构
的基本操作，并解决了实际问题。
实验结果表明，我们对数据结构的理解和应
用能力得到了提高，并且加深了对计算机科学的认识。
六、结论
本次北邮数据结构实验通过实践操作，加深了对数据结构的理解和应用能力。
通过团队合作，我们成功设计和实现了线性表、栈、队列、二叉树和图等数据
结构的基本操作，并解决了实际问题。
实验结果表明，我们对数据结构的理解
和应用能力得到了提高，并且加深了对计算机科学的认识。
希望通过这次实验，能够为我们今后的学习和工作打下坚实的基础。