北京邮电大学数值与符号计算实验报告

北京邮电大学微机原理软件实验报告信息与通信工程学院微机原理软件实验报告班级：姓名：学号：班内序号：时间：微机原理软件实验·报告实验一DEBUG 的使用一、实验目的1.掌握汇编程序的编辑,编译,连接和执行的全过程；2.学习和掌握用DEBUG 调试程序的方法。

二、实验内容1. 用编辑软件，输入以下汇编语言源程序：DAT SEGMENTA DB 20 ;(自定)B DB 15 ;(自定)Y DB 3 DUP (0)Z DB 0, 0DAT ENDSSTA SEGMENT STACKDW 50 DUP (?)STA ENDSCOD SEGMENTASSUME CS: COD, DS: DATSTAR PROC FARPUSH DSXOR AX, AXPUSH AXMOV AX, DATMOV DS, AXMOV AX, STAMOV SS, AXMOV AL, AMOV Z, ALMOV Z+1, ALCALL SUB1MOV AL,B微机原理软件实验·报告MOV Z,ALMOV Z+1,ALCALL SUB1MOV AL,AMOV Z,ALMOV AL,BMOV Z+1,ALCALL SUB1ADD WORD PTR Y,AXADC BYTE PTR[Y+2],0RETSTAR ENDPSUB1 PROCMOV AL, ZMOV AH, Z+1MUL AHADD WORD PTR Y, AXADC BYTE PTR[Y+2], 0RETSUB1 ENDPCOD ENDSEND STAR2. 通过编译，连接形成可执行文件。

3. 用DEBUG 将可执行文件调入，并进行调试。

1) 用D 命令观察数据区在内存中的具体内容，记录单元A 和B 的具体地址。

2) 用U 命令对目标代码反汇编，观察反汇编后的结果。

注意发现源程序的起始位置，并记录这个起始地址。

3) 用T 命令作单步跟踪调试。

比较每条指令执行后的结果和原来的理解是否一致，得出程序运行的结果：它们是写在什么单元,具体内容是什么；并判断结果是否正确。

《电路与电子学基础》实验报告实验名称班级学号姓名实验3交流电路的性质实验3.1 串联交流电路的阻抗 一、实验目的1.测量串联RL 电路的阻抗和交流电压与电流之间的相位，并比较测量值与计算值。

2.测量串联RC 电路的阻抗和交流电压与电流之间的相位，并比较测量值与计算值。

3.测量串联RLC 电路的阻抗和交流电压与电流之间的相位，并比较测量值与计算值。

二、实验器材双踪示波器 1台 信号发生器 1台 交流电流表 1个 交流电压表 1个 0.1µF 电容 1个 100mH 电感 1个 1K Ω电阻 1个三、实验准备两个同频率周期函数(例如正弦函数)之间的相位差，可通过测量两个曲线图之间及曲线一个周期T 的波形之间的时间差t 来确定。

因为时间t 与周期T 之比等于相位差θ(单位：度)与一周相位角的度数（360°）之比θ/360°=t/T所以，相位差可用下式计算θ=t(360°)/T在图3-1，图3-2和图3-3中交流电路的阻抗Z 满足欧姆定律，所以用阻抗两端的交流电压有效值V Z 除以交流电流有效值I Z 可算出阻抗(单位：Ω)IzVz Z =在图3-1中RL 串联电路的阻抗Z 为电阻R 和感抗XL 的向量和。

因此阻抗的大小为22LXRZ +=阻抗两端的电压VZ 与电流IZ 之间的相位差可由下式求出⎪⎭⎫⎝⎛=RXLarctan θ图3-1 RL 串联电路的阻抗在图3-2中RC 串联电路的阻抗Z 为电阻R 和容抗Xc 的向量和，所以阻抗的大小为CXR Z 22+=阻抗两段的电压Vz 和电流Iz 之间的相位差为⎪⎭⎫⎝⎛-=R X C arctan θ 当电压落后于电流时，相位差为负。

图3-2 RC 串联电路的阻抗在图3-3中RLC 串联电路的阻抗Z 为电阻 R 和电感与电容的总电抗X 之向量和，总电抗X 等于感抗XL 与容抗Xc 的向量和。

因此感抗与容抗之间有180°的相位差，所以总电抗X 为C LX XX -=这样，RLC 串联电路的阻抗大小可用下式求出22XRZ +=阻抗两端的电压Vz 与电流Iz 之间的相位差为⎪⎭⎫⎝⎛=R X arctan θ图3-3 RLC 串联电路的阻抗感抗X L 和容抗Xc 是正弦交流电频率的函数。

北邮数据结构实验报告北京邮电大学信息与通信工程学院2009级数据结构实验报告实验名称：实验三哈夫曼编/解码器的实现学生姓名：陈聪捷日期：2010年11月28日1.实验要求一、实验目的：了解哈夫曼树的思想和相关概念;二、实验内容：利用二叉树结构实现哈夫曼编/解码器1.初始化：能够对输入的任意长度的字符串s进行统计，统计每个字符的频度，并建立哈夫曼树。

2.建立编码表：利用已经建好的哈夫曼树进行编码，并将每个字符的编码输出。

3.编码：根据编码表对输入的字符串进行编码，并将编码后的字符串输出。

4.译码：利用已经建好的哈夫曼树对编码后的字符串进行译码，并输出译码结果。

5.打印：以直观的方式打印哈夫曼树。

6.计算输入的字符串编码前和编码后的长度，并进行分析，讨论哈夫曼编码的压缩效果。

7.用户界面可以设计成“菜单”方式，能进行交互，根据输入的字符串中每个字符出现的次数统计频度，对没有出现的字符一律不用编码。

2.程序分析2.1存储结构二叉树templateclassBiTree{public:BiTree();//构造函数，其前序序列由键盘输入~BiTree(void);//析构函数BiNode*Getroot();//获得指向根结点的指针protected:BiNode*root;//指向根结点的头指针};//声明类BiTree及定义结构BiNodeData：二叉树是由一个根结点和两棵互不相交的左右子树构成data:HCode*HCodeTable;//编码表inttSize;//编码表中的总字符数二叉树的节点结构templatestructBiNode//二叉树的结点结构{Tdata;//记录数据Tlchild;//左孩子Trchild;//右孩子Tparent;//双亲};编码表的节点结构structHCode{chardata;//编码表中的字符charcode[100];//该字符对应的编码};待编码字符串由键盘输入，输入时用链表存储，链表节点为structNode{charcharacter;//输入的字符unsignedintcount;//该字符的权值boolused;//建立树的时候该字符是否使用过Node*next;//保存下一个节点的地址};示意图：2.2关键算法分析1.初始化函数(voidHuffmanTree::Init(stringInput))算法伪代码：1.初始化链表的头结点2.获得输入字符串的第一个字符，并将其插入到链表尾部,n=1(n 记录的是链表中字符的个数)3.从字符串第2个字符开始，逐个取出字符串中的字符3.1将当前取出的字符与链表中已经存在的字符逐个比较，如果当前取出的字符与链表中已经存在的某个字符相同，则链表中该字符的权值加1。

实验名称：程序设计实验实验时间：2023年X月X日实验地点：北邮计算机实验室一、实验目的1. 熟悉C语言编程环境，掌握基本的程序设计方法。

2. 通过实际编程，提高逻辑思维和问题解决能力。

3. 理解算法设计的重要性，掌握常用的算法设计方法。

二、实验内容本次实验主要分为以下几个部分：1. 编写一个计算两个整数相加的程序。

2. 编写一个计算两个整数相减的程序。

3. 编写一个计算两个整数相乘的程序。

4. 编写一个计算两个整数相除的程序（要求考虑除数为0的情况）。

5. 编写一个判断两个整数是否相等的程序。

三、实验步骤1. 打开C语言编程环境，创建一个新的项目。

2. 编写计算两个整数相加的程序：```c#include <stdio.h>int main() {int a, b, sum;printf("请输入两个整数：\n");scanf("%d %d", &a, &b);sum = a + b;printf("两个整数相加的结果为：%d\n", sum); return 0;}```3. 编写计算两个整数相减的程序：```c#include <stdio.h>int main() {int a, b, sub;printf("请输入两个整数：\n");scanf("%d %d", &a, &b);sub = a - b;printf("两个整数相减的结果为：%d\n", sub); return 0;}```4. 编写计算两个整数相乘的程序：```c#include <stdio.h>int main() {int a, b, mul;printf("请输入两个整数：\n");scanf("%d %d", &a, &b);mul = a b;printf("两个整数相乘的结果为：%d\n", mul);return 0;}```5. 编写计算两个整数相除的程序（考虑除数为0的情况）：```c#include <stdio.h>int main() {int a, b, div;printf("请输入两个整数：\n");scanf("%d %d", &a, &b);if (b == 0) {printf("除数不能为0，请重新输入。

北京邮电大学数字电路与逻辑设计实验报告学院：xxxx学院姓名：xxx班级：xxxxxxxxxx128学号：xxxxxxxxxx实验一Quartus II原理图输入法设计与实现一、实验目的（1）熟悉用Quartus II原理图输入法进行电路设计和仿真；（2）掌握Quartus II图形模块单元的生成与调用；（3）熟悉实验板的使用。

二、实验所用仪器及元器件（1）计算机；（2）直流稳压电源；（3）数字系统与逻辑设计实验开发板。

三、实验任务要求（1）用逻辑门设计实现一个半加器，仿真验证其功能，并生成新的半加器图形模块单元。

（2）用实验（1）中生成的半加器模块和逻辑门设计实现一个全加器，仿真验证其功能，并下载到实验板测试，要求用拨码开关设定输入信号，发光二极管显示输出信号。

（3）用3线-8线译码器（74LS138）和逻辑门设计实现函数，仿真验证其功能，并下载到实验板测试。

要求用拨码开关设定输入信号，发光二极管显示输出信号。

四、实验原理图及仿真波形图228328（1）半加器【实验原理图】【仿真波形图】【仿真波形图分析】由波形图可以看出，真值表如下：a b so co 000001101010111由此可得，，满足半加器的设计要求。

（2）全加器428【实验原理图】【仿真波形图】【仿真波形图分析】由波形图可以看出真值表如下：ain bin cin sum cout 00000001100101001101100101115281100111111用分别表示信号ain 、bin 、cin 、sum 和cout ，则可得逻辑表达式为满足全加器的设计要求。

（3）3线-8线译码器实现函数【实验原理图】【仿真波形图】【仿真波形图分析】由波形图可得真值表如下：A B C F00010011010101101000101011001111则逻辑表达式为。

实验二用VHDL设计与实现组合逻辑电路一、实验目的（1）熟悉用VHDL语言设计组合逻辑电路的方法；（2）熟悉用Quartus II文本输入法进行电路设计；（3）熟悉不同的编码及其之间的转换。

北京邮电大学数字电路与逻辑设计实验发光二极管走马灯的电路设计与实现实验报告学院：信息与通信工程学院班级：27姓名：付莹学号：班内序号：23【实验目的】（1）进一步了解时序电路描述方法;（2）熟悉状态机的设计方法。

【实验所用仪器及元器件】（1）计算机；（2）直流稳压电源；（3）数字系统与逻辑设计实验开发板。

【实验任务要求】设计并实现一个控制8个发光二极管亮灭的电路，仿真验证其功能，并下载到实验板测试。

（1）单点移动模式：一个点在8个发光二极管上来回的亮（2）幕布式：从中间两个点，同时向两边依次点亮直到全亮，然后再向中间点灭，依次往复。

【实验设计思路及过程】（1）设计思路实验要求有两个，一个是单点移动模式，一个是幕布式。

通过CASE-WHEN 语句实现走马灯的变化。

分别定义一个8个变量的数据类型和一个13变量的数据类型，表示一个周期内的灯的变化，并设计一个变量在两种状态间进行切换。

此时，需要把所有状态罗列到case-when中去。

（2）VHDL代码LIBRARY IEEE;USE ABC ISPORT(A,CLK,RESET:IN STD_LOGIC;DENG:OUT STD_LOGIC_VECTOR(7 DOWNTO 0));END ABC;ARCHITECTURE A OF ABC ISTYPE STATE_TEMP is(s0,s1,s2,s3,s4,s5,s6,s7);TYPE STATE_TEMP1 is(s0,s1,s2,s3,s4,s5,s6,s7,s00,s01,s02,s03,s04,s05);signal STATE:STATE_TEMP;signal STATE1:STATE_TEMP1;BEGINPROCESS(CLK,RESET)BEGINIF RESET='1' THENDENG<="00000000";ELSIF(CLK'EVENT AND CLK='0')THENIF A='0'THEN --KAIMUSHICASE STATE1 ISWHEN s0 => STATE1<=s1;DENG<="";WHEN s1 => STATE1<=s2;DENG<="01000000";WHEN s2 => STATE1<=s3;DENG<="00100000";WHEN s3 => STATE1<=s4;DENG<="00010000";WHEN s4 => STATE1<=s5;DENG<="00001000";WHEN s5 => STATE1<=s6;DENG<="00000100";WHEN s6 => STATE1<=s7;DENG<="00000010";WHEN s7 =>STATE1<=s00;DENG<="00000001";WHEN s00=>STATE1<=s01;DENG<="00000010";WHEN s01=>STATE1<=s02;DENG<="00000100";WHEN s02=>STATE1<=s03;DENG<="00001000";WHEN s03=>STATE1<=s04;DENG<="00010000";WHEN s04=>STATE1<=s05;DENG<="00100000";WHEN s05=>STATE1<=s0;DENG <="01000000";END CASE;ELSECASE STATE ISWHEN s0 => STATE<=s1;DENG<="00011000";WHEN s1 => STATE<=s2;DENG<="00111100";WHEN s2 => STATE<=s3;DENG<="01111110";WHEN s3 => STATE<=s4;DENG<="";WHEN s4 => STATE<=s5;DENG<="01111110";WHEN s5 => STATE<=s6;DENG<="00111100";WHEN s6 => STATE<=s7;DENG<="00011000";WHEN s7 => STATE<=s0;DENG<="00000000";END CASE;END IF;END IF;END PROCESS;END A;【仿真波形及分析】1.仿真波形(1)单点移动式（2）幕布式（3）复位信号2.波形分析（1）单点移动式由图可以看出，当A为0时程序实现单点移动功能，如图所示DENG[7]开始亮，之后依次为DENG[6], DENG[5], DENG[4], DENG[3], DENG[2],DENG[1], DENG[0],然后DENG[1]也开始亮，依此类推，实现了功能要求（2）幕布式由图可以看出，当A为1时，如图所示，先是中间的两个灯DENG[4], DENG[5]亮，然后扩展到四个灯亮DENG[3]至DENG[6]亮，接下来是DENG[2]~DENG[7]亮，最后全亮，接着DENG[2]~DENG[7]亮，继而循环下去。

算法设计与分析第三章程序作业源程序代码1.最长公共子序列#include<stdio.h>#include<stdlib.h>#define N 1000int e[N][N],f[N][N];void LCSLength(int m,int n,char *x,char *y,int c[][N],int b[][N])//构造数组b[i][j]{int i,j;for (i=1; i<=m;i++)c[i][0]=0; //初始化, Y[j]为空时for (i=1;i<=n;i++)c[0][i]=0; //初始化，X[i]为空时for (i=1;i<=m;i++) //两重循环，自下而上，// 计算子问题{X(i), Y(j)}for (j=1;j<=n;j++){if(x[i]==y[j]){ //情况1c[i][j]=c[i-1][j-1]+1;b[i][j]=1;}else if(c[i-1][j]>=c[i][j-1]){ //情况2c[i][j]=c[i-1][j];b[i][j]=2;}else //情况3{c[i][j]=c[i][j-1];b[i][j]=3;}}}void LCS(int i,int j,char *x,int b[][N]){if (i==0||j==0)return;if (b[i][j]==1){LCS(i-1,j-1,x,b);printf("%c",x[i]);/*第1种情况下，X(i)和Y(j)的最长公共子序列由X(i-1)和Y(j-1)的解LCS(i-1, j-1, x, b)，加上位于最后的X[i]组成*/}else if(b[i][j]==2)LCS(i-1,j,x,b);elseLCS(i,j-1,x,b); //其它2种情况下，原问题解等于子问题解}main(){char A[N],B[N],C[N],D[N];int a=1,b=1,c=1,d=1;char ch;int i;FILE * fp;if((fp=fopen("最长公共子序列输入数据.txt","r"))==NULL)//打开文件失败printf("Can't open file ");else{//读取文件内容ch=fgetc(fp);ch=fgetc(fp);ch=fgetc(fp);ch=fgetc(fp);ch=fgetc(fp);while(ch!='B'&&ch!=EOF) {A[a]=ch;a++;ch=fgetc(fp);while(ch=='\n')ch=fgetc(fp);}a--;ch=fgetc(fp);ch=fgetc(fp);ch=fgetc(fp);ch=fgetc(fp);while(ch!='C'&&ch!=EOF) {B[b]=ch;b++;ch=fgetc(fp);while(ch=='\n')ch=fgetc(fp);}b--;ch=fgetc(fp);ch=fgetc(fp);ch=fgetc(fp);ch=fgetc(fp);while(ch!='D'&&ch!=EOF) {C[c]=ch;c++;ch=fgetc(fp);while(ch=='\n')ch=fgetc(fp);}c--;ch=fgetc(fp);ch=fgetc(fp);ch=fgetc(fp);ch=fgetc(fp);while(ch!=EOF){D[d]=ch;d++;ch=fgetc(fp);while(ch=='\n')ch=fgetc(fp);}d--;}fclose(fp);printf("文件读取完成\n");/* for(i=0;i<=a;i++)printf("%c",A[i]);printf("\n");for(i=0;i<=b;i++)printf("%c",B[i]);printf("\n");for(i=0;i<=c;i++)printf("%c",C[i]);printf("\n");for(i=0;i<=d;i++)printf("%c",D[i]);printf("\n"); */printf("\n\n\nA和B的最长公共子序列为：\n");LCSLength(a,b,A,B,e,f);LCS(a,b,A,f);printf("\n\n\nC和D的最长公共子序列为：\n");LCSLength(c,d,C,D,e,f);LCS(c,d,C,f);printf("\n\n\nA和D的最长公共子序列为：\n");LCSLength(a,d,A,D,e,f);LCS(a,d,A,f);system("pause");return 0;}2.最大子段和#include<stdio.h>#include<stdlib.h>#define N 400void MaxSum(int n,int *a){int sum=0,b=0;int i,x1=0,y1=0,x=0,y=0;for(i=1;i<=n;i++){if (b>0){b+=a[i];y1=i;}else{b=a[i];x1=i;}if(b>sum){sum=b;x=x1;y=y1;}}printf("\n该序列的最大子段和的位置为从第%d个到第%d个",x+1,y+1);printf("\n该序列的和最大子段为：\n");for(i=x;i<=y;i++)printf("%d ",a[i]);printf("\n它们的和为%d \n",sum);}main(){int A[N],B[N];int a=0,b=0;int i;FILE *fp1,*fp2;if((fp1=fopen("最大子段和输入数据-序列1.txt","r"))==NULL)//打开文件失败printf("Can't open file1 ");else //读取文件内容for(i=0;!feof(fp1);i++)fscanf(fp1,"%d\n",&A[i]);a=i-1;}if((fp2=fopen("最大子段和输入数据-序列2.txt","r"))==NULL)//打开文件失败printf("Can't open file2 ");else{for(i=0;!feof(fp2);i++)fscanf(fp2,"%d\n",&B[i]);b=i-1;}fclose(fp1);fclose(fp1);printf("文件读取成功！！！\n\n\n");printf("对于最大子段和输入数据-序列1 ");MaxSum(a,A);//计算最大子段和printf("\n\n对于最大子段和输入数据-序列2 ");MaxSum(b,B);// for(i=0;i<=b;i++)// printf("%d ",B[i]);system("pause");return 0;}3.凸多边形最优三角剖分#include<stdio.h>#include<stdlib.h>#include<math.h>#define N 30#define EARTH_RADIUS 6378.137struct Base{//基站结构体int ENODEBID;//基站标识float LONGITUDE;//基站经度float LATITUDE;//基站纬度int NUM;//基站k-dist距离};void readfile(struct Base * base,int n) //读取文件函数{FILE * fp;int i=0;if(n==21)fp=fopen("21个基站凸多边形数据.csv","rb");elsefp=fopen("29个基站凸多边形数据.csv","rb");if(fp==NULL)//打开文件失败printf("Can't open file ");else{while(EOF!=fscanf(fp,"%d,%f,%f,%d",&base[i].ENODEBID,&base[i].LO NGITUDE,&base[i].LATITUDE,&base[i].NUM)){//将数据读入结构体数组i++;//printf("%d\n",i);}// printf("文件读入成功！！！\n\n\n");fclose(fp);}float rad(float LatOrLon){return LatOrLon * 3.14/180.0;}float distance(struct Base * base,int a,int b)//求两个基站间的距离{float s;float radLat1,radLat2,radlng1,radlng2;radLat1 = rad(base[a].LATITUDE);radLat2 = rad(base[b].LATITUDE);radlng1 = rad(base[a].LONGITUDE);radlng2 = rad(base[b].LONGITUDE);//利用正弦余弦公式求距离if(radLat1==radLat2&&radlng1==radlng2)s=0;elses=acos(cos(radLat1)*cos(radLat2)*cos(radlng1-radlng2)+sin(radLat1)*s in(radLat2));s = s * EARTH_RADIUS;s=round(s*1000);}return s;}float weight(struct Base * base,int a,int b,int c){float s,s1,s2,s3;s1=distance(base,a,b);s2=distance(base,b,c);s3=distance(base,a,c);//s=distance(base,a,b)+distance(base,b,c)+distance(base,a,c);s=s1+s2+s3;return s;}float MinWeightTriangulation(struct Base * base,int n,float t[][N],int s[][N]){int i,j,r,k;float u=0;for(i=1;i<=n;i++)t[i][i]=0;for(r=2;r<=n;r++) //r为当前计算的链长（子问题规模）for(i=1;i<=n-r+1;i++)//n-r+1为最后一个r链的前边界{j=i+r-1;//计算前边界为r，链长为r的链的后边界t[i][j]=t[i+1][j]+weight(base,i-1,i,j);//将链ij划分为A(i) * ( A[i+1:j] )这里实际上就是k=is[i][j]=i;for (k=i+1;k<i+r-1;k++) //将链ij划分为( A[i:k] )* (A[k+1:j]){u=t[i][k]+t[k+1][j]+weight(base,i-1,k,j);if(u<t[i][j]){t[i][j]=u;s[i][j]=k;}}}return t[1][n];}void Traceback(int i,int j,int s[][N]){if(i==j)return;Traceback(i,s[i][j],s);Traceback(s[i][j]+1,j,s);printf("三角剖分顶点：V%d , V%d , V%d\n",i-1,j,s[i][j]); }main(){int i;float t[N][N];int s[N][N];struct Base base21[N];//结构体（N宏定义）struct Base base29[N];//结构体（N宏定义）readfile(base21,21);//将数据从文件中读到结构体中readfile(base29,29);//将数据从文件中读到结构体中printf("文件读入成功！！！\n\n\n");// for(i=0;i<=28;i++)//printf("%6d %.3f %.5f %d\n",base29[i].ENODEBID,base29[i].LONGITU DE,base29[i].LATITUDE,base29[i].NUM);printf("凸21多边形的最优三角剖分值为%f",MinWeightTriangulation(base21,20,t,s));printf("最优三角剖分结构为：\n");Traceback(1,20,s); //s[i][j]记录了Vi-1和Vj构成三角形的第3个顶点的位置printf("凸29多边形的最优三角剖分值为%f",MinWeightTriangulation(base29,28,t,s));printf("最优三角剖分结构为：\n");Traceback(1,28,s); //s[i][j]记录了Vi-1和Vj构成三角形的第3个顶点的位置system("pause");return 0;}4.01背包问题#include<stdio.h>#include<stdlib.h>#define N 100struct Goods{int weight;//物品重量int value;//物品价值};int knapsack(struct Goods *goods,int bag,int number,int p[][2],int head[]){int left=0,right=0,next=1,i,j,k,m,y;p[0][0]=0;p[0][1]=0;head[number+1]=0;head[number]=1;for(i=number;i>=1;i--){k=left;for(j=left;j<=right&&p[j][0]+goods[i-1].weight<=bag;j++){ y=p[j][0]+goods[i-1].weight;m=p[j][1]+goods[i-1].value;while(k<=right&&p[k][0]<y){p[next][0]=p[k][0];p[next][1]=p[k][1];next++;k++;}if(k<=right&&p[k][0]==y){if(m<p[k][1]){m=p[k][1];}k++;}if(m>p[next-1][1]){p[next][0]=y;p[next][1]=m;next++;}while(k<=right&&p[k][1]<=p[next-1][1]){k++;}}while(k<=right){p[next][0]=p[k][0];p[next][1]=p[k][1];next++;k++;}left=right+1;right=next-1;head[i-1]=next;}return next;}void traceback(struct Goods *goods,int number,int head[],int p[][2],int x[]){int j=p[head[0]-1][0],m=p[head[0]-1][1];int i,k,a;for(i=1;i<=number;i++){x[i]=0;a=1;// for(k=3450;k<=head[i]-1&&a==1;k++)for(k=head[i+1];k<=head[i]-1&&a==1;k++){if(p[k][0]+goods[i-1].weight==j&&p[k][1]+goods[i-1].value==m){x[i]=1;j=p[k][0];m=p[k][1];a=0;}}}}main(){int bag1,bag2;//背包容量int number1,number2;//物品数目int i,n;int p[20000][2];int h[N],x[N];struct Goods goods1[N],goods2[N];FILE *fp;char ch='0';if((fp=fopen("附件4.背包问题输入数据.txt","r"))==NULL)//打开文件失败printf("Can't open file ");else //读入背包和物品信息{fseek(fp,18,SEEK_CUR);fscanf(fp,"%d",&bag1);//背包1容量fseek(fp,18,SEEK_CUR);ch='0';for(i=0;ch!='\n';i++){fscanf(fp,"%d",&goods1[i].weight);//物品重量}number1=i;ch='0';fseek(fp,14,SEEK_CUR);for(i=0;ch!='\n'&&ch!=EOF;i++){fscanf(fp,"%d",&goods1[i].value);//物品价值ch=fgetc(fp);}if(number1!=i){printf("读取数据出错，程序将退出！\n");system("pause");}fseek(fp,22,SEEK_CUR);fscanf(fp,"%d",&bag2);//背包1容量fseek(fp,18,SEEK_CUR);ch='0';for(i=0;ch!='\n';i++){fscanf(fp,"%d",&goods2[i].weight);//物品重量}number2=i;ch='0';fseek(fp,14,SEEK_CUR);for(i=0;ch!='\n'&&ch!=EOF;i++){fscanf(fp,"%d",&goods2[i].value);//物品价值ch=fgetc(fp);}if(number2!=i){printf("读取数据出错，程序将退出！\n");system("pause");}}printf("文件读取成功！！！\n");/*打印文件的信息*/printf("\n\n第一组背包数据：\n");printf("背包容量：%d 物品数量：%d\n物品重量：\n",bag1,number1);for(i=0;i<number1;i++)printf("%d ",goods1[i].weight);printf("\n物品价值：\n");for(i=0;i<number1;i++)printf("%d ",goods1[i].value);printf("\n\n第二组背包数据：\n");printf("背包容量：%d 物品数量：%d\n物品重量：\n",bag2,number2);for(i=0;i<number2;i++)printf("%d ",goods2[i].weight);printf("\n物品价值：\n");for(i=0;i<number2;i++)printf("%d ",goods2[i].value);n=knapsack(goods1,bag1,number1,p,h);traceback(goods1,number1,h,p,x); //确定放入的物品//打印结果printf("\n\n第一组：\n背包重量为：%d 背包价值为：%d\n",p[n-1][0],p[n-1][1]);printf("放入的物品为：\n");for(i=1;i<number1;i++)if(x[i]==1)printf("物品%-2d 重量%-2d 价值%d\n",i,goods1[i-1].weight,goods1[i-1].value);//第二组数据n=knapsack(goods2,bag2,number2,p,h);traceback(goods2,number2,h,p,x);printf("\n\n第二组：\n背包重量为：%d 背包价值为：%d\n",p[n-1][0],p[n-1][1]);printf("放入的物品为：\n");for(i=1;i<number2;i++)if(x[i]==1)printf("物品%-2d 重量%-2d 价值%d\n",i,goods2[i-1].weight,goods2[i-1].value);system("pause");return 0;}运行结果1.最长公共子序列2.最大子段和3.凸多边形最优三角剖分4.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 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[] 中。

数据结构实验报告实验名称：__ 哈夫曼树________学生姓名：______ 蔡宇豪_________________班级：________ 2 5____________________ 班内序号：__________15__________________学号：_________2012210673___________________ 日期：________2013.11.24____________________2. 程序分析2.1 存储结构哈夫曼树结点的存储结构包括双亲域parent，左子树lchild，右子树rchild，还有字符word，权重weight，编码code对用户输入的信息进行统计，将每个字符作为哈夫曼树的叶子结点。

统计每个字符出现的次数作为叶子的权重，统计次数可以根据每个字符不同的ASCII码，根据叶子结点的权重建立一个哈夫曼树2.2 关键算法分析要实现哈夫曼解/编码器，就必须用二叉树结构建立起哈夫曼树，其中有4个关键算法，首先是初始化函数，统计每个字符的频度，并建立起哈夫曼树；然后是建立编码表，将每个字符的编码输出；再次就是编码算法，根据编码表对输入的字符串进行编码，并将编码后的字符串输出；最后是译码算法，利用已经建好的赫夫曼树对编码后的字符串进行译码，并输出译码结果。

1.初始化函数int i,j;for(i=0;i<MAX;i++)a[i]=0; //先将a[]数组中每个值都赋为，不然程序会运行出错？for(i=0;s[i]!='\0';i++) //'\0'字符串结束标志{for(j=0;j<n;j++){if(s[i]==b[j]) //判断该字符是否已经出现过break;}if(j<n) //该字符出现过，对应计数器加一a[j]++;else//该字符为新字符,上面的循环全部运行完毕，j=n，记录到b[j]中，对应计数器加一{b[j]=s[i];a[j]++;n++; //出现的字符种类数加一}}//cout<<"共有"<<n<<"种字符，分别为:"<<endl;for(i=0;i<n;i++)cout<<b[i]<<"出现次数为:"<<a[i]<<endl;HTree=new HNode[2*n-1] ; //哈夫曼树初始化for(int i=0;i<2*n-1;i++){if(i<n){HTree[i].weight=a[i];}else{HTree[i].weight=0;}HTree[i].LChild=-1;HTree[i].RChild=-1;HTree[i].parent=-1;}int x,y,m1,m2; //x,y用于存放权值最小结点在数组中的下标for(int i=n;i<2*n-1;i++) //开始建哈夫曼树{//找出权值最小的结点m1=m2=MAX; //MAX=1000x=y=0;for(int j=0;j<i;j++){if(HTree[j].weight<m1&&HTree[j].parent==-1){m2=m1;m1=HTree[j].weight;x=j;}else if(HTree[j].weight < m2 && HTree[j].parent==-1){m2=HTree[j].weight;y=j;}}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;2.生成编码表HCodeTable=new HCode[n];for(int i=0;i<n;i++){HCodeTable[i].data=b[i];int child=i;int parent=HTree[i].parent;int k=0;while(parent!=-1){if(child==HTree[parent].LChild)HCodeTable[i].code[k]='0';elseHCodeTable[i].code[k]='1';k++;child=parent;parent=HTree[child].parent;}HCodeTable[i].code[k]='\0';cout<<b[i]<<"的编码:";for(int j=k-1;j>=0;j--)cout<<HCodeTable[i].code[j];cout<<endl;}3.编码cout<<"编码后的字符串为:";while(*d!='\0'){for(int i=0;i<n;i++){if(b[i]==*d) //判断，每当出现一种时，就找到对应编码并输出{int k=strlen(HCodeTable[i].code);for(int j=k-1;j>=0;j--){*s=HCodeTable[i].code[j];cout<<*s;s++;}}}d++;}*s='\0';cout<<endl;【计算关键算法的时间、空间复杂度】关键算法A的时间复杂度为O(n)，关键算法B的时间复杂度为O(n),关键算法C的时间复杂度为O(n)，关键算法D的时间复杂度为O(n).2.3 其他程序完整代码：#include<iostream>using namespace std;const int MAX=1000;struct HNode{int weight;int parent;int LChild;int RChild;};struct HCode{char data;char code[200];};class Huffman{private:HNode *HTree; //哈夫曼树HCode *HCodeTable; //哈夫曼编码表char b[MAX]; //记录出现的字符int a[MAX]; //记录每个字符出现的次数，即权值static int n; //字符的种类数(静态变量)public:void init(char s[]); //初始化void init1(char s[]);void CreateCodeTable(); //创建编码表void Encoding(char *s,char *d); //编码void Decoding(char *s,char *d); //解码int count1() //算编码前长度{int q1=0;for(int i=0;i<n;i++){q1+=8*a[i];}return q1;}int count2() //算编码后长度{int q2=0;for(int i=0;i<n;i++){q2+=strlen(HCodeTable[i].code)*a[i];}return q2;}};int Huffman::n=0;void Huffman::init(char s[]){int i,j;for(i=0;i<MAX;i++)a[i]=0; //先将a[]数组中每个值都赋为，不然程序会运行出错？for(i=0;s[i]!='\0';i++) //'\0'字符串结束标志{for(j=0;j<n;j++){if(s[i]==b[j]) //判断该字符是否已经出现过break;}if(j<n) //该字符出现过，对应计数器加一a[j]++;else//该字符为新字符,上面的循环全部运行完毕，j=n，记录到b[j]中，对应计数器加一{b[j]=s[i];a[j]++;n++; //出现的字符种类数加一}}//cout<<"共有"<<n<<"种字符，分别为:"<<endl;for(i=0;i<n;i++)cout<<b[i]<<"出现次数为:"<<a[i]<<endl;HTree=new HNode[2*n-1] ; //哈夫曼树初始化for(int q=0;q<2*n-1;q++){if(q<n){HTree[q].weight=a[q];}else{HTree[q].weight=0;}HTree[q].LChild=-1;HTree[q].RChild=-1;HTree[q].parent=-1;}int x,y,m1,m2; //x,y用于存放权值最小结点在数组中的下标for(int w=n;w<2*n-1;w++) //开始建哈夫曼树{//找出权值最小的结点m1=m2=MAX; //MAX=1000x=y=0;for(int j=0;j<i;j++){if(HTree[j].weight<m1&&HTree[j].parent==-1){m2=m1;m1=HTree[j].weight;x=j;}else if(HTree[j].weight < m2 && HTree[j].parent==-1){m2=HTree[j].weight;y=j;}}HTree[x].parent=HTree[y].parent=w;HTree[w].weight=HTree[x].weight+HTree[y].weight;HTree[w].LChild=x;HTree[w].RChild=y;HTree[w].parent=-1;}}void Huffman::init1(char s[]){int i,j;for(i=0;i<MAX;i++)a[i]=0; //先将a[]数组中每个值都赋为，不然程序会运行出错？for(i=0;s[i]!='\0';i++) //'\0'字符串结束标志{for(j=0;j<n;j++){if(s[i]==b[j]) //判断该字符是否已经出现过break;}if(j<n) //该字符出现过，对应计数器加一a[j]++;else//该字符为新字符,上面的循环全部运行完毕，j=n，记录到b[j]中，对应计数器加一{b[j]=s[i];a[j]++;n++; //出现的字符种类数加一}}HTree=new HNode[2*n-1] ; //哈夫曼树初始化for(int e=0;e<2*n-1;e++){if(e<n){HTree[e].weight=a[e];}else{HTree[e].weight=0;}HTree[e].LChild=-1;HTree[e].RChild=-1;HTree[e].parent=-1;}int x,y,m1,m2; //x,y用于存放权值最小结点在数组中的下标，m1,m2用于存放两个无父结点且结点权值最小的两个结点for(int r=n;r<2*n-1;r++) //开始建哈夫曼树{//找出权值最小的结点m1=m2=MAX; //MAX=1000x=y=0;for(int j=0;j<r;j++){if(HTree[j].weight<m1&&HTree[j].parent==-1){m2=m1;//y=x;m1=HTree[j].weight;x=j;}else if(HTree[j].weight < m2 && HTree[j].parent==-1){m2=HTree[j].weight;y=j;}}HTree[x].parent=HTree[y].parent=r;HTree[r].weight=HTree[x].weight+HTree[y].weight;HTree[r].LChild=x;HTree[r].RChild=y;HTree[r].parent=-1;}}void Huffman::CreateCodeTable() //生成编码表{HCodeTable=new HCode[n];for(int i=0;i<n;i++){HCodeTable[i].data=b[i];int child=i;int parent=HTree[i].parent;int k=0;while(parent!=-1){if(child==HTree[parent].LChild)HCodeTable[i].code[k]='0';elseHCodeTable[i].code[k]='1';k++;child=parent;parent=HTree[child].parent;}HCodeTable[i].code[k]='\0';cout<<b[i]<<"的编码:";for(int j=k-1;j>=0;j--)cout<<HCodeTable[i].code[j];cout<<endl;}}void Huffman::Encoding(char *s,char *d) // 编码算法 //d为字符串{cout<<"编码后的字符串为:";while(*d!='\0'){for(int i=0;i<n;i++){if(b[i]==*d) //判断，每当出现一种时，就找到对应编码并输出{int k=strlen(HCodeTable[i].code);for(int j=k-1;j>=0;j--){*s=HCodeTable[i].code[j];cout<<*s;s++;}}}d++;}*s='\0';cout<<endl;}void Huffman::Decoding(char *s,char *d) //s为编码串{cout<<"解码后的字符串为:";while(*s!='\0'){int parent=2*n-1-1;while(HTree[parent].LChild!=-1){if(*s=='0')parent=HTree[parent].LChild;elseparent=HTree[parent].RChild;s++;}*d=HCodeTable[parent].data;cout<<*d;d++;}cout<<endl;void main(){int i=0;char d[MAX];char s[MAX];cout<<"请输入字符串:";while((d[i]=getchar())!='\n')i++;d[i]='\0';Huffman h;cout<<"哈夫曼功能："<<endl;cout<<"1.统计字符种类及出现次数"<<endl;cout<<"2.数据的编码解码"<<endl;cout<<"3.分析压缩效果"<<endl;int q;for(;;){cout<<"请输入（1~3）"<<endl;cin>>q;bool x=0;switch (q){case 1:h.init(d);break;case 2:h.init1(d);h.CreateCodeTable();h.Encoding(s,d);h.Decoding(s,d);break;case 3:cout<<"编码前的长度为:"<<h.count1()<<endl;cout<<"编码后的长度为:"<<h.count2()<<endl;cout<<"压缩比为:"<<(h.count2()*1.0/h.count1())<<endl;break;default:cout<<"请输入选择！！！！！"<<endl;break;}}3.}程序运行结果分析输入：I love data Structure, I love Computer。

信息论实验·第一次实验报告题目一：掷毂子游戏的熵实验步骤：（程序见附件）我们首先计算掷毂子游戏熵的理论值：首先可以得到加和为2、3、…12的概率分别为1/36、2/36….6/36、5/36…1/36，然后利用公式：可以得到掷毂子游戏的熵的理论值为3.27bit/符号。

然后计算熵的仿真值：首先设定N=100:100:100000，然后做N次试验，统计最后加和的值所出现的频率，用频率近似概率，再次利用以上公式，得到仿真熵。

最后对不同的N得到的仿真熵与理论值的差别作图，寻找规律。

实验结论：经过理论分析，我们可知加和为2、3、…12的概率分别为1/36、2/36….6/36、5/36…1/36，进而得到掷毂子游戏的熵的理论值为3.27bit/符号。

下图为N取不同值时仿真熵的变化曲线（N=100:100:100000）：根据观察可以得到，当N逐渐增大时，仿真熵逐渐趋近于理论计算得到的熵3.27bit/符号。

题目一（可选）：计算英文文本的熵实验步骤：（程序见附件）首先，我们导入了一段样本文本，节选自欧亨利的小说《警察与赞美诗》（文本见附件），统计这段文本中英文字母（区分大小写）和空格出现的个数，进而得到各个字母出现的概率p(x)，然后利用公式：计算样本的熵H(X)。

然后，我们统计了文本中相邻两个字符出现的概率p(xy)，通过计算边缘概率分布可得p(x)，然后利用公式p(y|x)=p(xy)/p(x)条件分布概率p(y|x)，最后利用公式：计算得到样本的相邻两个字符的条件熵H(Y|X)。

最后，我利用生成了一组独立等概分布的英文随机序列，重新计算H(X)、H(Y|X)，以检验模型的正确性。

实验结论：首先，我们可得实验的结果列表：输入文本测试项目实验值理论值小说节选H(X) 4.21bit/symbol 4.03bit/symbol小说节选H(Y|X) 3.14bit/symbol 3.32bit/symbol随机序列H(X) 5.72bit/symbol 5.73bit/symbol随机序列H(Y|X) 5.51bit/symbol 5.73bit/symbol 在上表中，实验值是通过matlab仿真得到，小说节选的两项理论值是通过查阅《信息论基础》（田宝玉、杨洁等编著，57页）得到，随机序列的理论值是通过计算：得到，随机序列共有53个符号，等概出现，我们认为H(Y|X)=H(Y)=。

数字电路综合实验报告学院：信息与通信工程学院班级：201*******班内序号：**学生姓名：****学号：201*******一：设计课题的任务要求-------------------------------------------------------------------------------3基本要求：------------------------------------------------------------------------------3提高要求：------------------------------------------------------------------------------3二：系统设计（包括设计思路、总体框图、分块设计）------------------------------------------3设计思路：-------------------------------------------------------------------------------3总体框图：-------------------------------------------------------------------------------4分块设计：------------------------------------------------------------------------------41：分频器------------------------------------------------------------------42：防抖模块---------------------------------------------------------------53：模式调节模块---------------------------------------------------------54：手动定时&默认定时模块------------------------------------------75：倒计时模块------------------------------------------------------------86：火力调节模块---------------------------------------------------------87：数码管驱动模块------------------------------------------------------98：led显示模块----------------------------------------------------------109：关机模块---------------------------------------------------------------1110：蜂鸣器模块----------------------------------------------------------1111：点阵显示模块-------------------------------------------------------11三：仿真波形及波形分析--------------------------------------------------------------------------------121：分频器-----------------------------------------------------------------122：模式选择模块--------------------------------------------------------133：定时模块--------------------------------------------------------------134：倒计时模块-----------------------------------------------------------145：火力调节模块--------------------------------------------------------146：led显示模块---------------------------------------------------------157：蜂鸣器模块-----------------------------------------------------------15四：源程序--------------------------------------------------------------------------------------------------16总程序结构和原理图------------------------------------------------------------------16各部分程序结构原理图---------------------------------------------------------------181：分频器-----------------------------------------------------------------182：防抖模块--------------------------------------------------------------203：模式控制模块--------------------------------------------------------204：定时&倒计时模块---------------------------------------------------235：火力调节模块--------------------------------------------------------286：数码管显示模块-----------------------------------------------------307：led显示模块---------------------------------------------------------328：关机模块-------------------------------------------------------------339：蜂鸣器模块-----------------------------------------------------------3410：点阵显示模块------------------------------------------------------34五：功能说明-----------------------------------------------------------------------------------------------38六：元件清单和利用情况--------------------------------------------------------------------------------38七：故障和问题分析--------------------------------------------------------------------------------------39八：总结和结论--------------------------------------------------------------------------------------------40一：设计课题的任务要求设计制作一个简易电磁炉控制器。

数字电路试验汇报学院: 信息与通信工程专业: 信息工程班级: 211125学号: 210681姓名: 袁普试验一: QuartusⅡ原理图输入法设计与实现一: 试验要求①: 用逻辑门设计实现一个半加器, 仿真验证其功效, 并生成新半加器图形模块单元。

②: 用试验一生成半加器模块和逻辑门设计实现一个全加器, 仿真验证其功效, 并下载到试验板测试, 要求用拨码开关设定输入信号, 发光二极管显示输出信号。

③: 用3线—8线译码器和逻辑门设计实现函数F, 仿真验证其功效, 下载到试验板测试。

要求用拨码开关设定输入信号, 发光二极管显示输出信号。

二: 汇报内容①: 试验一（2）原理图用两个已经生成半加器图形模块单元和一个双输入或门即可实现全加器②: 仿真波形图以及分析波形图:波形分析: 经过分析ab ci三个输入在8中不一样组合下输出, 发觉与全加器真值表吻合, 说明实现了全加器逻辑功效。

同时看见波形中出现了毛刺（冒险）, 这也与事实一致。

③: 故障及问题分析第一次在做全加器时候发觉找不到已经生成半加器模块, 以后发觉是因为在建立工程时这两个项目没有建在同一个文件夹里, 在调用时候就找不到。

以后我将全加器工程建在同一个文件夹里处理了此问题。

试验二: 用VHDL设计和实现组合逻辑电路一: 试验要求①: 用VHDL设计一个8421码转换为格雷码代码转换器, 仿真验证其功效。

②: 用VHDL设计一个4位二进制奇校验器, 要求在为奇数个1时输出为1, 偶数个1时输出为0, 仿真验证其功效。

③: 用VHDL设计一个数码管译码器, 仿真验证其功效, 下载到试验板测试, 要求用拨码开关设定输入信号, 数码管显示输出信号, 而且只使一个数码管有显示, 其它为熄灭状态。

二: 故障及问题分析在刚开始实现让一个数码管显示时候, 我原来准备再设置6个输入和输出, 经过试验板上拨码来输入信息分别控制不一样数码管开闭状态, 不过以后发觉这么效率很低而且试验板上拨码开关数量根本不够。

数值分析实验报告实验一、解线性方程组的直接方法——梯形电阻电路问题利用追赶法求解三对角方程组的方法，解决梯形电阻电路问题：电路中的各个电流{1i ，2i ，…，8i }须满足下列线性方程组：R V i i =- 22 210 252321=-+-i i i 0 252 432=-+-i i i 0 252 543=-+-i i i 0 252 654=-+-i i i 0 252 765=-+-i i i 0 252 876=-+-i i i 052 87=+-i i设V 220=V ，Ω=27R ，运用追赶法，求各段电路的电流量。

问题分析：上述方程组可用矩阵表示为：⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡=⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡--------------00000001481.8522520000002520000002520000002520000002520000002520000002287654321i i i i i i i i问题转化为求解A x b =，8阶方阵A 满足顺序主子式(1,2...7)0i A i =≠，因此矩阵A存在唯一的Doolittle 分解，可以采用解三对角矩阵的追赶法！追赶法a=[0 -2 -2 -2 -2 -2 -2 -2]; b=[2 5 5 5 5 5 5 5]；c=[-2 -2 -2 -2 -2 -2 -2 0]; d=[220/27 0 0 0 0 0 0 0];Matlab 程序function x= zhuiganfa( a,b,c,d )%追赶法实现要求：|b1|>|C1|>0,|bi|>=|ai|+|ci| n=length(b); u=ones(1,n); L=ones(1,n); y=ones(1,n); u(1)=b(1); y(1)=d(1); for i=2:nL(i)=a(i)/u(i-1);u(i)=b(i)-c(i-1)*L(i); y(i)=d(i)-y(i-1)*L(i); endx(n)=y(n)/u(n); for k=n-1:-1:1x(k)=(y(k)-c(k)*x(k+1))/u(k); end endMATLAB 命令窗口输入：a=[0 -2 -2 -2 -2 -2 -2 -2]; b=[2 5 5 5 5 5 5 5];c=[-2 -2 -2 -2 -2 -2 -2 0] d=[220/27 0 0 0 0 0 0 0];x= zhuiganfa(a,b,c,d )运行结果为：x =8.1478 4.0737 2.0365 1.0175 0.5073 0.2506 0.1194 0.0477存在问题根据电路分析中的所讲到的回路电流法，可以列出8个以回路电流为独立变量的方程，课本上给出的第八个回路电流方程存在问题，正确的应该是78240i i -+=；或者可以根据电路并联分流的知识，同样可以确定78240i i -+=。

题目: 简易猜数字游戏机的设计与实现姓名学院专业班级学号班内序号一、设计课题的任务要求基本要求：1、游戏规则：通常由两个人玩，一方出数字，另一方猜。

出数字的人要想好一个没有重复数字的 4 位数，不能让猜的人知道。

2、数字设置：通过 4*4 键盘进行 4 位数字输入,在数码管（DISP0~DISP3）上显示当前所输入的数字。

通过设置确定键（BTN1 键）进行锁定，此时数码管上的数值消失，同时用点阵开始倒计时，即：初始状态点阵全亮，然后从右下角开始，由右到左、由下到上逐点逐排依次熄灭，间隔时间为 1s，共计 64s。

3、猜数字：可以通过 4*4 键盘进行 4 位数字输入进行猜数字，且每输入一位数字在数码管（DISP0~DISP3）上显示当前所输入的数字，按确定键（BTN2 键）进行确认，此时要根据输入的这组数字给出几 A 几 B，其中：A前面的数字表示位置正确的数的个数，用DISP5显示B前的数字表示数字正确而位置不对的数的个数，用DISP4显示如正确答案为 2134，而猜的人猜 5314，则是1A2B，其中有一个4的位置对了，记为1A，而1和3这三个数字对了，而位置没对，因此记为 2B，合起来就是 1A2B 接着猜的人再根据出题者的几A几B继续猜，直到猜中（即 4A0B）为止。

4、若数字正确则显示猜数字成功，点阵显示“☺”笑脸；若输入数字错误系统仍然处于猜数字状态，点阵显示“X”，并用蜂鸣器或 led 闪烁报警。

5、若到点阵全灭时(64s 结束)仍未猜出正确数字，游戏失败，点阵显示“囧”。

6、设置游戏机开关。

提高要求：1、若数字正确则显示猜数字成功，用蜂鸣器播放一段乐曲。

2、随机产生数字，并不在数码管上显示，进行猜数字游戏，用点阵进行 128s 计时，即点阵轮询熄灭两次，其他要求同基本功能3、4 和 5。

3、自拟其他功能。

二、系统设计设计思路：首先是状态机的设定，设定了5个状态，分别是idle、s1、s2、s3和over。

2009级数据结构实验报告实验名称：实验二栈和队列学生姓名：班级：班内序号：学号：日期：2010年12月18日实验要求题目四用栈做计算器。

设计一个算术四则运算表达式求值的简单计算器。

表达式求值是程序设计语言编译中最近本的问题，它要求把一个表达式翻译成能够直接求值的序列。

基本要求：输入中缀表达式能够转化成后缀表达式，比如输入中缀表达式“(A+B)*C”，输出“AB+C*”2、操作数使用单字母变量A、B、C等表示，操作符仅为+、-、*、/、（和）；3、能够对变量A、B、C等赋值，得出正确的计算结果2. 程序分析首先，程序要求用户输入一个符号表达式，只能包含字母、+、-、*、/ 以及）和（，之后程序会用一个TurnInfixToPostfix（）函数将表达式转化成后缀表达式存入一个栈中，转化过程借用逆波兰算法，建立一个符号栈，遍历用户输入的表达式，如果是字母，则直接输出，如果是运算符，则压入符号栈中（包括括号），在压栈的时候又需要注意，先要检查压栈前栈顶元素的优先级，如果优先级高于要压入的符号则直接压入该符号，否则要弹栈直到栈顶元素的优先级小于该元素的优先级然后才将该符号压入栈中（在压栈的时候会涉及到栈中有括号的情况，具体细节下面会说到），将转化的后缀表达式存入栈postfix，在输出的时候只要弹栈就行。

然后，要求用户逐个输入表达式中的字母的值，这时候，需要遍历当时在转化后缀表达式的时候过度容器vec_intoposfix，如果是字母则要求用户输入数值，压入用于计算的后缀表达式容器，如果是操作符则直接压入。

最后，在利用栈来计算值的时候，利用一个递归函数，就是一次弹栈，如果是操作符则先保存起来，接着继续弹栈，如果接下来的两个元素都为数字，就将这两个数字做相应的运算，然后压栈，如此反复，最后压入栈的元素就是表达式的值。

至此，程序的功能全部实现。

2.1 存储结构[内容要求]1、存储结构：顺序表、单链表或其他存储结构，需要画示意图，可参考书上P59页图2-92.2 关键算法分析关键算法一：将中缀表达式转化为后缀表达式VoidTurnInfixToPostfix(vector<char>&vec,stack<char>&sta,vector<char>&vecfix,stack< char>&stafix)1、 {2、int priority(-1);3、4、for (vector<char>::iterator itr=vec.begin();itr!=vec.end();itr++)5、{6、if(isLetter(*itr))7、{8、vecfix.push_back(*itr);9、}10、if (isOperator(*itr))11、{12、if(!sta.empty()) priority=getPriority(sta.top());13、else priority=-1;14、if (priority<getPriority(*itr)||priority==3&&sta.top()!=')')15、{16、sta.push(*itr);17、}18、else19、{20、if (sta.top()!=')')21、{22、while(priority>=getPriority(*itr)&&sta.top()!='(')23、{24、vecfix.push_back(sta.top());25、if (!sta.empty())26、{27、sta.pop();28、if(!sta.empty()) priority=getPriority(sta.top());29、else priority=-1;30、}31、else32、break;33、}34、sta.push(*itr);35、}36、else if(sta.top()==')')37、{38、while (sta.top()!='(')39、{40、vecfix.push_back(sta.top());41、if (!sta.empty()&&sta.top()!='(')42、{43、sta.pop();44、}45、else46、break;47、}48、}49、}50、51、52、}53、54、}55、for (vector<char>::iteratoritrfix=vecfix.end();itrfix!=vecfix.begin();--itrfix)56、stafix.push(*itrfix);57、stafix.push(*itrfix);58、}对表达式a + b * c – ( d – e) / f + g其符号栈的变化过程，红色表示未压栈的符号。

北京邮电⼤学数字信号处理实验⼆数字信号处理实验⼆XX 班 XX XX⼀．实验要求： (1) 假设信号 x(n) 由下述信号组成：这个信号有两根主谱线 0.3pi 和 0.302pi 靠的⾮常近，⽽另⼀根谱线0.45pi 的幅度很⼩，请选择合适的长度 N 和窗函数，⽤ DFT 分析其频谱，得到清楚的三根谱线。

(2) 已知： N=25。

这⾥ Q=0.9+j0.3。

可以推导出，⾸先根据这个式⼦计算 X(k) 的理论值，然后计算输⼊序列 x(n) 的 32 个值，再利⽤基 2 时间抽选的 FFT 算法，计算 x(n) 的 DFT X(k)，与 X(k) 的理论值⽐较（要求计算结果最少 6 位有效数字）。

⼆．实验分析：（1）本实验可使⽤matlab 中⾃带的fft 函数求得x(n)的傅⾥叶变换，难点在于选择合适的N 值以及清楚的谱线。

a.对于N 值的选择，由于x （n ）中包含的三个分量的周期分别为2*pi/0.45*pi=40/9,2*pi/0.3pi=20/3,2*pi/0.302pi=1000/151,x （n ）的周期为1000，为得到清晰的谱线，选取N=1000，则Wk=2*pi*k/1000；所以三条谱线的k1=450，k2=300,k3=302;b.在使谱线清洗时，只需利⽤axis 选取合适的窗函数即可。

（2）本实验即为要求先利⽤25点DFT 的定义计算求得其25点DFT ，再利⽤基2-FFT 算法求得其DFT ，并且将两者进⾏⽐较。

三．实验内容的实现（1）A.代码：n=0:1:999; xn=0.001*cos(0.45*pi*n)+sin(0.3*pi*n)-cos(0.302*pi*n); yn=fft(xn,1000);%对xn 进⾏1000点DFTk1=0:1:499;wk=2*pi/1000*k1;y1=yn(1:1:500);%由于镜像对称只需看⼀半即可 subplot(3,1,1);stem(wk/pi,abs(y1));title('Samples of DTFT Magnitude');xlabel('frequency in pi units');axis([0,1,0,600]);subplot(3,1,2);stem(wk/pi,abs(y1));axis([0.25,0.35,0,600]);%观察300,302处的谱线subplot(3,1,3);stem(wk/pi,abs(y1));axis([0.4,0.5,0,1]);%观察450处谱线B.结果如图： 1()(N n X k x n -==∑00010450303024().*cos(.)sin(.)cos(.)x n n n n ππππ=+--（2）A．代码：format longQ=0.9+0.3i;n=0:24;x=Q.^n;y1=(1-Q^25)./(1-Q.*exp(-j*2*pi*n/25)); %根据公式计算25点DFTx2=[x,0,0,0,0,0,0,0];y2=fft(x2);%使⽤基2FFT算法计算n2=0:1:31;for(m=1:25)y3(m)=y1(m)-y2(m);end;subplot(3,1,1);stem(n,abs(y1));axis([0,32,0,15]);title('N=25 DFT');xlabel('n');subplot(3,1,2);stem(n2,abs(y2));axis([0,32,0,15]);title('N=32 FFT');xlabel('n');subplot(3,1,3);stem(m,abs(y3));axis([0,25,0,15]);title('误差');xlabel('n');B.结果：a.误差序列：y3 =Columns 1 through 2-0.000000000000000 - 0.000000000000000i 5.817439454324326 -0.941040324114136iColumns 3 through 4-9.272989245757216 + 1.806567024126041i -1.055728571003527 + 0.006165567483396i Columns 5 through 60.109680274228142 + 0.312117411678918i -0.132227359831744 + 0.656545304970248i Columns 7 through 8-0.491115210532073 + 0.330164381661244i -0.302355254463930 - 0.104401629339881i Columns 9 through 100.071488794285995 - 0.066464473299359i 0.078075844225558 + 0.210934398903539i Columns 11 through 12-0.161974868948978 + 0.209654292048469i -0.176095334975308 - 0.034516239063079i Columns 13 through 140.060246199972530 - 0.092272809496693i 0.154494521140728 + 0.108487641370809i Columns 15 through 16-0.006434841285029 + 0.208660575204784i -0.095307033403866 + 0.059377350932753i Columns 17 through 180.068999600677699 - 0.043113757045075i 0.222166621724661 + 0.111157325552887i Columns 19 through 200.130789688425025 + 0.289360758130739i 0.001288211584027 + 0.236449*********i Columns 21 through 220.118110781165706 + 0.132488509392841i 0.344473749291525 + 0.292907236433923i Columns 23 through 240.363759326481941 + 0.632526704462872i 0.268854435642791 + 0.852006047941478i Column 250.501096763217777 + 1.111762593982078ib.DFT 基2-FFT 误差序列的频谱。