南京邮电大学算法实验报告
南邮操作系统实验三
南邮操作系统实验三实验报告（ 2014/ 2015 学年第一学期）课程名称操作系统教程实验名称页面调度算法的模拟实现实验时间2014 年12 月 3 日指导单位计算机软件学院指导教师徐鹤学生姓名楚灵翔班级学号B12040731 学院(系) 计算机学院专业软件工程实验报告实验名称页面调度算法的模拟实现指导教师徐鹤实验类型上机实验学时 2 实验时间2014.12.3一、实验目的和要求1、模拟实现页面调度算法中的FIFO、LRU和OPT算法2、进程的页面请求序列，即一系列页面号（页面号用整数表示，用空格作为分隔符），用来模拟待换入的页面；3、输出要求：显示缺页的总次数和缺页中断率二、实验环境(实验设备)VMware Workstation，Ubuntu三、实验过程描述#define n 12#define m 3int page[n]; //保存需要访问的页面int i,j,q,mem[m]={0},List[m][n],sum;char flag,f[n];void Init();void FIFO();void LRU();void main(){cout<<"*********************实验***********************"<<endl;< bdsfid="127" p=""></endl;<> cout<<" ┏━━━━━━━━━━━━━━━━━━━━━━━┓"<<endl;< bdsfid="129" p=""></endl;<>cout<<" ┃页面调度算法的模拟实现┃"<<endl;< bdsfid="131" p=""></endl;<>cout<<" ┠───────────────────────┨"<<endl;< bdsfid="133" p=""></endl;<>cout<<" ┃先进先出算法FIFO ┃"<<endl;< bdsfid="135" p=""></endl;<>cout<<" ┃最近追少使用算法LRU ┃"<<endl;< bdsfid="137" p=""></endl;<>cout<<" ┗━━━━━━━━━━━━━━━━━━━━━━━┛"<<endl;< bdsfid="139" p=""></endl;<>cout<<" 请输入页面访问序列:\n"<<" ";for(i=0;i<n;i++)< bdsfid="142" p=""></n;i++)<>cin>>page[i];cout<<endl;< bdsfid="145" p=""></endl;<>FIFO();Init();LRU();}void Init() //初始化函数{sum=0; //初始化计算缺页次数的变量for(int i=0;i<m;i++)< bdsfid="153" p=""></m;i++)<>mem[i]=0;for(i=0;i<m;i++)< bdsfid="156" p=""></m;i++)<>for(j=0;j<n;j++)< bdsfid="158" p=""></n;j++)<>List[i][j]=0;}void FIFO(){for(i=0;i<="">{q=0;while((page[i]!=mem[q])&&(q!=m))q++;if(q==m)flag='*'; //缺页，则置标志flag为'*' elseflag=' ';if(flag=='*'){for(j=m-1;j>0;j--) //淘汰最先调入的页面调入当前访问的mem[j]=mem[j-1];mem[0]=page[i];}for(j=0;j<m;j++)< bdsfid="178" p=""></m;j++)<>List[j][i]=mem[j];f[i]=flag;}cout<<" 0代表为空,*代表有缺页:\n";cout<<endl;< bdsfid="184" p=""></endl;<>cout<<"-----------FIFO算法结果------------"<<endl;< bdsfid="186" p=""></endl;<>for(i=0;i<m;i++)< bdsfid="188" p=""></m;i++)<>{for(j=0;j<n;j++)< bdsfid="191" p=""></n;j++)<>cout<<list[i][j]<<" ";<="" bdsfid="193" p=""></list[i][j]<<"> cout<<endl;}< bdsfid="195" p=""></endl;}<>for(i=0;i<n;i++)< bdsfid="197" p=""></n;i++)<>{if(f[i]=='*')sum++;cout<<f[i]<<" ";<="" bdsfid="202" p=""></f[i]<<">}cout<<"\n-----------------------------------"<<endl;<bdsfid="205" p=""></endl;<>cout<<"缺页次数是:"<<sum<<"缺页率是:"<<<endl;<="" bdsfid="207" p=""></sum<<"缺页率是:"<}void LRU(){for(i=0;i<="">{q=0;while((page[i]!=mem[q])&&(q!=m))q++;if(q==m)flag='*'; //缺页，则置标志flag为'*'elseflag=' ';for(j=q;j>0;j--)mem[j]=mem[j-1];mem[0]=page[i];for(j=0;j<m;j++)< bdsfid="225" p=""></m;j++)<>List[j][i]=mem[j];f[i]=flag;}cout<<endl;< bdsfid="229" p=""></endl;<>cout<<"------------LRU算法结果------------"<<endl;< bdsfid="231" p=""></endl;<>for(i=0;i<m;i++)< bdsfid="233" p=""></m;i++)<>{for(j=0;j<n;j++)< bdsfid="236" p=""></n;j++)<>cout<<list[i][j]<<" ";<="" bdsfid="238" p=""></list[i][j]<<"> cout<<endl;< bdsfid="240" p=""></endl;<>}for(i=0;i<n;i++)< bdsfid="243" p=""></n;i++)<>{if(f[i]=='*')sum++;cout<<f[i]<<" ";}<="" bdsfid="248" p=""></f[i]<<">cout<<endl;< bdsfid="250" p=""></endl;<>cout<<"-----------------------------------"<<endl;<bdsfid="252" p=""></endl;<>cout<<"缺页次数是:"<<sum<<"缺页率是:"<<<=""></sum<<"缺页率是:"<实验结果：四、实验小结（包括问题和解决方法、心得体会、意见与建议等）通过本次实验,我对于页面调度算法有了更加深刻的认识。
南邮ACM算法与数据结构设计(2010-2011-2实验三简评)
实验（作业） 实验（作业）三简评
D、五位以内的对称素数
来源： 来源： 第1187题 题 题目描述：判断一个数是否为对称且不大于五位数的素数。 题目描述：判断一个数是否为对称且不大于五位数的素数。 输入描述：输入数据含有不多于50个的正整数 个的正整数(0<n<232)。 输入描述：输入数据含有不多于 个的正整数 。 输出描述：对于每个n，如果该数是不大于五位数的对称素数， 输出描述：对于每个 ，如果该数是不大于五位数的对称素数，则输出 “Yes”，否则输出“No”。每个判断结果单独列一行。 ，否则输出“ 。每个判断结果单独列一行。 输入样例
实验（作业） 实验（作业）三简评
C、完数
来源： 来源： 第1190题 题 题目描述：自然数中，完数寥若晨星，请在从 到某个整数范围中打印出 题目描述：自然数中，完数寥若晨星，请在从1到某个整数范围中打印出 所有的完数来。所谓“完数”是指一个数恰好等于它的所有不同因子之和。 所有的完数来。所谓“完数”是指一个数恰好等于它的所有不同因子之和。 例如， 是完数 因为6=1+2+3。而24不是完数，因为 是完数， 不是完数， 例如，6是完数，因为 。 不是完数 因为24≠1+2+3+4+6+8+12 ＝36。 。 输入描述：输入数据中含有一些整数 （ ＜ ＜ 输入描述：输入数据中含有一些整数n（1＜n＜10000）。 ）。 输出描述：对于每个整数 ，输出所有不大于n的完数 每个整数n的输出 的完数。 输出描述：对于每个整数n，输出所有不大于 的完数。每个整数 的输出 引导， 由n引导，跟上冒号，然后是由空格开道的一个个完数，每个 的完数列表 引导 跟上冒号，然后是由空格开道的一个个完数，每个n的完数列表 应占独立的一行。 应占独立的一行。 输入样例
南京邮电大学算法分析与设计实验报告——密码算法
实验报告（2013/2014学年第一学期）课程名称算法分析与设计实验名称密码算法实验时间2014 年 5 月23 日指导单位计算机学院软件工程系指导教师张怡婷学生姓名班级学号B******** 学院(系) 软件工程专业软件工程实验报告三、实验原理及内容（包括操作过程、结果分析等）实验步骤1、RSA 算法是由麻省理工学院的Ron Rivest,Adi Shamir 和Len Adleman 于1977 年研制并于1978 年首次发表的一种算法，是第一个能同时用于加密和数字签名的算法，且易于理解和操作，因此作为一种通用公开密钥加密方式而受到推崇。
RSA 是一种分组密码，其中明文和密文都是小于某个n 的从0 到n-1 的整数，则分组的二进制值长度必须小于或等于log2n。
若以M 表示明文分组，而C 表示密文分组，则加密和解密的过程如下：C=Me mod nM=Cd mod n=(Me)d mod n=Med mod n发送方和接受方都必须知道n 的值。
发送方知道 e 的值，而只有接受方知道d 的值。
因此这是一种公开密钥为{e,n}，且私有密钥为{d,n}的公开密钥加密算法。
此时算法要能够满足公开密钥加密的要求，则必须满足以下条件：（1）有可能找到e、d、n 的值，使得对所有M<n 有Med=M mod n。
（2）对于所有M<n 的值，要计算Me和Cd 相对来说是简单的。
（3）在给定e 和n 时，判断出 d 是不可行的。
2、重点考虑第一个条件：由Euler 定理的一个推论：给定两个素数p和q以及两个整数n 和m，使得n=pq 而且0<m<n，并且对于任意整数k，下列关系成立：mkΦ(n)+1=mk(p-1)(q-1)+1≡m mod n其中Φ(n)是欧拉函数，也就是不超过n 且与n 互素的整数个数。
对于素数p 和q，有Φ(pq)=(p-1)(q-1)。
因此得到需要的关系：ed=kΦ(n)+1，等价于: ed≡1 mod Φ(n)d≡e-1 mod Φ(n)也就是说：d 和 e 是以Φ(n)为模的乘法逆元。
算法课设实验报告(3篇)
第1篇一、实验背景与目的随着计算机技术的飞速发展，算法在计算机科学中扮演着至关重要的角色。
为了加深对算法设计与分析的理解，提高实际应用能力，本实验课程设计旨在通过实际操作，让学生掌握算法设计与分析的基本方法，学会运用所学知识解决实际问题。
二、实验内容与步骤本次实验共分为三个部分，分别为排序算法、贪心算法和动态规划算法的设计与实现。
1. 排序算法（1）实验目的：熟悉常见的排序算法，理解其原理，比较其优缺点，并实现至少三种排序算法。
（2）实验内容：- 实现冒泡排序、快速排序和归并排序三种算法。
- 对每种算法进行时间复杂度和空间复杂度的分析。
- 编写测试程序，对算法进行性能测试，比较不同算法的优劣。
（3）实验步骤：- 分析冒泡排序、快速排序和归并排序的原理。
- 编写三种排序算法的代码。
- 分析代码的时间复杂度和空间复杂度。
- 编写测试程序，生成随机测试数据，测试三种算法的性能。
- 比较三种算法的运行时间和内存占用。
2. 贪心算法（1）实验目的：理解贪心算法的基本思想，掌握贪心算法的解题步骤，并实现一个贪心算法问题。
（2）实验内容：- 实现一个贪心算法问题，如活动选择问题。
- 分析贪心算法的正确性，并证明其最优性。
（3）实验步骤：- 分析活动选择问题的贪心策略。
- 编写贪心算法的代码。
- 分析贪心算法的正确性，并证明其最优性。
- 编写测试程序，验证贪心算法的正确性。
3. 动态规划算法（1）实验目的：理解动态规划算法的基本思想，掌握动态规划算法的解题步骤，并实现一个动态规划算法问题。
（2）实验内容：- 实现一个动态规划算法问题，如背包问题。
- 分析动态规划算法的正确性，并证明其最优性。
（3）实验步骤：- 分析背包问题的动态规划策略。
- 编写动态规划算法的代码。
- 分析动态规划算法的正确性，并证明其最优性。
- 编写测试程序，验证动态规划算法的正确性。
三、实验结果与分析1. 排序算法实验结果：- 冒泡排序：时间复杂度O(n^2)，空间复杂度O(1)。
南京邮电大学算法设计实验报告——动态规划法
if(a[i]==b[j]) {
c[i][j]=c[i-1][j-1]+1; s[i][j]=1; } else if(c[i-1][j]>=c[i][j-1]) { c[i][j]=c[i-1][j]; s[i][j]=2; } else { c[i][j]=c[i][j-1]; s[i][j]=3; } } } return c[m][n]; //返回最优解值 }
算法分析与设计 A
动态规划法
2009
年 11 月 20 日
计算机学院软件工程系
张怡婷
学生姓名 学院(系)
丁力琪 班级学号 计算机学院 专 业
B07030907 软件工程
实验报告
实验名称
动态规划法
指导教师 张怡婷
实验类型
验证
实验学时 2×2 实验时间 2009-11-20
一、 实验目的和任务
目的：加深对动态规划法的算法原理及实现过程的理解，学习用动态
6
8、输入序列 X={x1,x2,……,xm}={a,b,c,b,d,a,b}和 Y={y1,y2,……,yn}={b,d,c,a,b,a}作为测 试数据，测试程序是否能够正确运行？输出结果是什么？ 运行正确，实验结果显示：4
bcba
9、分析该动态规划算法的两个主要成员函数 int LCSLength()和 void CLCS()的时间复杂 性。
#include<iostream> #include<string> using namespace std; #define maxlength 11 class LCS { public:
南邮数据结构实验一
南邮数据结构实验一实验报告（2014 / 2015学年第一学期）课程名称数据结构实验名称二叉树基本操作以及哈夫曼编码译码系统实验时间年月日指导单位指导教师学生姓名班级学号学院(系) 专业二叉树的基本运算：一、问题描述1.设计递归算法，实现二叉树的运算：删除一棵二叉树，求一棵二叉树的高度，求一棵二叉树中叶子节点数，复制一棵二叉树，交换一棵二叉树的左右子树2.设计算法，自上而下，自左向右即按层次遍历一棵二叉树3.设计main函数，测试上述每个运算二、系统分析和概要设计首先用maketree构造一棵二叉树，然后遍历二叉树，然后交换每个结点的左右子树，接着算出输得高度和叶子节点，最后删除。
三、详细设计2. 核心算法建立二叉树的void MakeTree(const T& x,BinaryTree& left,BinaryTree& right)和计算叶子节点的int Size();3. 算法分析删除一棵二叉树，求一棵二叉树的高度，求一棵二叉树中叶子节点数，复制一棵二叉树等都是用递归的方法实现。
四、程序代码流程图#includetemplatestruct BTNode{BTNode(){lChild=rChild=NULL;}BTNode(const T &x){element=x;lChild=rChild=NULL;}BTNode(const T &x,BTNode* l,BTNode* r) {element=x;lChild=l;rChild=r;}T element;BTNode* lChild,* rChild;};templateclass BinaryTree{public:BinaryTree(){root=NULL;}~BinaryTree(){Clear();}void Copy(BinaryTree&r) const;bool IsEmpty()const{return root == NULL;}void Clear();void Exchange();bool Root(T& x)const;int GetHeight();void MakeTree(const T& x,BinaryTree& left,BinaryTree& right);void BreakTree(T& x,BinaryTree& left,BinaryTree& right);void PreOrder(void (*Visit)(T &x));void LevelOrder(void (*Visit)(T& x));int Size();BinaryTree(BinaryTree&t)root=Copy(t.root);}// void InOrder(void (*Visit)(T &x));// void PostOrder(void (*Visit)(T &x));BTNode* Copy(BTNode* t);protected:BTNode * root;private:static int number;void Clear(BTNode* &t);void Exchange(BTNode* t);int GetHeight(BTNode* t);int Size(BTNode* t);void PreOrder(void (*Visit)(T &x),BTNode* t);void LevelOrder(void (*Visit)(T& x),BTNode* t); // void InOrder(void (*Visit)(T &x),BTNode* t);// void PostOrder(void (*Visit)(T &x),BTNode* t); };templatebool BinaryTree::Root(T &x)const{if(root){x=root->element;return true;}elsereturn false;}templatevoid BinaryTree::Clear(){Clear(root);}templatevoid BinaryTree::Clear(BTNode* &t){if(t)Clear(t->lChild);Clear(t->rChild);delete t;t=NULL;}}templatevoid BinaryTree::MakeTree(const T& x,BinaryTree& left,BinaryTree& right) {if(root||&left==&right)return;root=new BTNode (x,left.root,right.root);left.root=right.root=NULL;}templatevoid BinaryTree::BreakTree(T& x,BinaryTree& left,BinaryTree& right) {if(!root||&left==&right||left.root||right.root)return;x=root->element;left.root=root->lChild;right.root=root->rChild;delete root;root=NULL;}templateBTNode* BinaryTree::Copy(BTNode* t){if(!t)return NULL;BTNode*q=new BTNode(t->element);q->lChild=Copy(t->lChild);q->rChild=Copy(t->rChild);return q;}templatevoid Visit(T &x){cout<<x<<" ";<="" bdsfid="252" p=""></x<<">}templatevoid BinaryTree::PreOrder(void (*Visit)(T& x)){PreOrder(Visit,root);}templatevoid BinaryTree::PreOrder(void (*Visit)(T& x),BTNode* t) { if(t){Visit(t->element);PreOrder(Visit,t->lChild);PreOrder(Visit,t->rChild);}}templatevoid BinaryTree::Exchange(){Exchange(root);}templatevoid BinaryTree::Exchange(BTNode* t){if(!t)return;BTNode* temp;temp=t->lChild;t->lChild=t->rChild;t->rChild=temp;Exchange(t->lChild);Exchange(t->rChild);}templateint BinaryTree::GetHeight(){return GetHeight(root);}int BinaryTree::GetHeight(BTNode* t) {int templ;int tempr;if(!t)return 0;templ=GetHeight(t->lChild);tempr=GetHeight(t->rChild);if(templ++>tempr++)return templ;elsereturn tempr;}templateint BinaryTree::number=0; templateint BinaryTree::Size(){Size(root);return number;}templateint BinaryTree::Size(BTNode* t){if(t!=NULL){Size(t->lChild);if(t->lChild ==NULL&&t->rChild ==NULL)number++;Size(t->rChild);}return number;}templatevoid BinaryTree::LevelOrder(void (*Visit)(T& x)) { PreOrder(Visit,root);}void BinaryTree::LevelOrder(void (*Visit)(T& x),BTNode* t) { BTNode *quene[50],*p;int pre=1,rear=1;quene[++pre]=t;while(pre!=0){p=quene[++rear];cout<element<<" ";if(p->lChild !=NULL)quene[++pre]=p->rChild ;if(p->rChild !=NULL)quene[++pre]=p->lChild ;}}void main(){BinaryTree a,b,x,y,z;y.MakeTree('E',a,b);z.MakeTree('F',a,b);x.MakeTree('C',y,z);y.MakeTree('D',a,b);z.MakeTree('B',y,x);cout<<"二叉树z的先序遍历:"<<endl;< bdsfid="378" p=""></endl;<>z.PreOrder(Visit);cout<<endl;< bdsfid="381" p=""></endl;<>cout<<"层次遍历二叉树:";z.LevelOrder(Visit);cout<<endl;< bdsfid="385" p=""></endl;<>BinaryTree q(z);cout<<"复制的二叉树q的先序遍历:"<<endl;< bdsfid="389" p=""></endl;<>q.PreOrder(Visit);cout<<endl;< bdsfid="392" p=""></endl;<>cout<<"树的高度:";cout<<z.getheight()<<endl;< bdsfid="395" p=""></z.getheight()<<endl;<>cout<<"叶子节点数量:";cout<<z.size()<<endl;< bdsfid="398" p=""></z.size()<<endl;<>z.Exchange();cout<<"二叉树左右子树交换后的先序遍历:"<<endl;< bdsfid="401" p=""></endl;<>z.PreOrder(Visit);cout<<endl;< bdsfid="404" p=""></endl;<>}五、测试用例和运行结果测试用例如main函数中所示，结果如下图所示。
南邮数学实验报告
南邮数学实验报告
实验目的：
本实验旨在帮助学生基于对不同数学概念的理解和应用，掌握
数学实验中的基本技能和科学方法，以及加强团队协作和实验报
告撰写能力。
实验内容：
1.选择适当的数列，并利用不同的方法来研究和描述该数列的
性质和规律。
2.利用数学软件工具如Mathematica和Excel等来验证和分析数
列的特征，并通过可视化图形进行展示。
3.完成实验报告和展示，并与同学和教师之间进行交流和互动。
实验步骤：
1.选择一个数列，并介绍其基本特征和规律。
2.利用手工计算和计算机软件工具进行数列的推导和验证。
3.绘制数列的图形表示，并通过图形分析来说明数列性质。
4.进行更深入的探索，如在数列之间搜索、联系和推理，并加
强对数学概念和方法的理解。
5.结合实验数据，形成文献综述和分析，并撰写实验报告。
实验结果：
通过实验学习和探索，我们深入了解了数列的性质和规律。
我
们还掌握了一些基本的数学实验技能，如数据分析、可视化图形、以及实验报告撰写等。
最重要的，我们加强了团队协作和沟通，
更好地理解和应用数学知识。
结论：
数学实验是帮助学生理解和应用数学知识的重要途径。
它不仅可以促进学生的动手能力和创新思维，还可以帮助学生加强团队协作和实验报告撰写能力。
对于未来从事科研工作的学生来说，数学实验将是非常有益的经验和见识。
南京邮电大学-数值计算实践报告
数值计算实践I 、方程求根一、实验目的熟悉和掌握Newton 法,割线法,抛物线法的方法思路，并能够在matlab 上编程实现二、问题描述(1).给定一个三次方程,分别用Newton 法,割线法,抛物线法求解. 方程的构造方法:(a)根:方程的根为学号的后三位乘以倒数第二位加1再除以1000. 假设你的学号为B06060141,则根为141*(4+1)/1000=0.564(b)方程:以你的学号的后三位数分别作为方程的三次项,二次项,一次项的系数,根据所给的根以及三个系数确定常数项. 例如:你的学号是B06060141,则你的方程是x 3+4x 2+x+a 0=0的形式. 方程的根为0.564,因此有0.5643+4*0.5642+0.564+a0=0,于是a0=-2.015790144 你的方程为x 3+4x 2+x-2.015790144=0.(2)假设方程是sinx+4x 2+x+a0=0的形式（三个系数分别是学号中的数字），重新解决类似的问题(3)构造一个五次方程完成上面的工作.四次方程的构造:将三次多项式再乘以(x-p*)2得到对应的五次多项式(p*为已经确定的方程的根,显然,得到的五次方程有重根).(4)将（2）中的方程同样乘以(x-p*)得到一个新的方程来求解注:(1)Newton 法取0.5为初值,割线法以 0,1为初值,抛物线法以0,0.5,1为初值, (2)计算精度尽量地取高.终止准则：根据ε<--||1n n p p 来终止(3)可供研究的问题：（一）ε的取值不同对收敛速度有多大的影响（二）将注（1）中的初值该为其它的初值，对收敛性以及收敛速度有无影响 （三）能否求出方程的所有的根 （4）实验报告的撰写实验报告包含的内容：（一）实验目的（二）问题描述（三）算法介绍（包括基本原理）（四）程序（五）计算结果（六）结果分析（七）心得体会三、算法介绍在本问题中，我们用到了newton 法，割线法，抛物线法。
南京邮电大学DSP实验报告
南京邮电大学实验报告实验名称：采样、系统性质及滤波系统频率响应和样本处理算法实现加窗和离散傅氏变换数字滤波器设计课程名称：数字信号处理姓名：学号开课时间2011 /2012 学年，第 2 学期实验一一．实验名称：采样、系统性质及滤波 二．实验目的和任务，实验内容：一、观察采样引起的混叠。
设模拟信号为)3sin()2sin(4)5cos()(t t t t x πππ⋅+=，t 的单位为毫秒(ms)。
1. 设采样频率为3kHz ，确定与)(t x 混叠的采样重建信号)(t x a 。
2. 画出)(t x 和)(t x a 在)(60ms t ≤≤范围内的连续波形。
（因数字计算机无法真正画出连续波形，可用较密的离散点的连线来近似。
）3. 分别用"" 和""⨯在两信号波形上标记出3kHz 采样点。
两信号波形是否相同？采样后的两序列是否相同？二、判别离散时间系统的时不变性。
（来源：p105 例3.2.2）设输入序列为)(n x ，系统)2()(n x n y =实现对)(n x 的抽取。
1. 设500,...,2,1),1002sin()(==n n n x π。
取延迟量D （例如D ＝30）。
记)()(D n x n x D -=，画出)(n x 、)(n x D 的序列波形。
2. 编程求出系统对)(n x 的响应)(n y 以及对)(n x D 的响应)(n y D3. 画出)(D n y -、)(n y D 的波形。
该系统是否为时不变的？三、利用卷积计算信号通过FIR 滤波器的输出，并观察输出信号的input-on 暂态、input-off暂态和稳态阶段。
（来源：p144 例4.1.8）考虑两个滤波器，⎩⎨⎧≤≤⋅=其它0140)75.0(25.0)(1n n h n ，]1,5,10,105,1[51--=，－2h ；输入)(n x 为周期方波，第一个周期内⎩⎨⎧≤≤≤≤=492502401)(x x n x 。
关于算法的实验报告(3篇)
第1篇一、实验目的1. 理解快速排序算法的基本原理和实现方法。
2. 掌握快速排序算法的时间复杂度和空间复杂度分析。
3. 通过实验验证快速排序算法的效率。
4. 提高编程能力和算法设计能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验原理快速排序算法是一种分而治之的排序算法，其基本思想是：选取一个基准元素，将待排序序列分为两个子序列，其中一个子序列的所有元素均小于基准元素，另一个子序列的所有元素均大于基准元素，然后递归地对这两个子序列进行快速排序。
快速排序算法的时间复杂度主要取决于基准元素的选取和划分过程。
在平均情况下，快速排序的时间复杂度为O(nlogn)，但在最坏情况下，时间复杂度会退化到O(n^2)。
四、实验内容1. 快速排序算法的代码实现2. 快速排序算法的时间复杂度分析3. 快速排序算法的效率验证五、实验步骤1. 设计快速排序算法的C++代码实现，包括以下功能：- 选取基准元素- 划分序列- 递归排序2. 编写主函数，用于生成随机数组和测试快速排序算法。
3. 分析快速排序算法的时间复杂度。
4. 对不同规模的数据集进行测试，验证快速排序算法的效率。
六、实验结果与分析1. 快速排序算法的代码实现```cppinclude <iostream>include <vector>include <cstdlib>include <ctime>using namespace std;// 生成随机数组void generateRandomArray(vector<int>& arr, int n) {srand((unsigned)time(0));for (int i = 0; i < n; ++i) {arr.push_back(rand() % 1000);}}// 快速排序void quickSort(vector<int>& arr, int left, int right) { if (left >= right) {return;}int i = left;int j = right;int pivot = arr[(left + right) / 2]; // 选取中间元素作为基准 while (i <= j) {while (arr[i] < pivot) {i++;}while (arr[j] > pivot) {j--;}if (i <= j) {swap(arr[i], arr[j]);i++;j--;}}quickSort(arr, left, j);quickSort(arr, i, right);}int main() {int n = 10000; // 测试数据规模vector<int> arr;generateRandomArray(arr, n);clock_t start = clock();quickSort(arr, 0, n - 1);clock_t end = clock();cout << "排序用时：" << double(end - start) / CLOCKS_PER_SEC << "秒" << endl;return 0;}```2. 快速排序算法的时间复杂度分析根据实验结果，快速排序算法在平均情况下的时间复杂度为O(nlogn)，在最坏情况下的时间复杂度为O(n^2)。
南京邮电大学实验报告 - 副本 - 副本
南京邮电大学实验报告 - 副本 - 副本实验名称：语音识别实验
实验目的：
1. 了解语音识别的基本概念和算法原理；
2. 掌握语音识别实验的基本方法和流程；
3. 学会使用Python语言进行语音信号处理和机器学习算法的实现。
实验器材：
1. 个人电脑；
2. Python编程环境；
3. PyAudio库；
4. 各类机器学习算法库。
实验流程：
1. 数据采集：使用PyAudio库对麦克风进行采样，获取语音信号；
2. 信号预处理：对采集到的语音信号进行预处理，如去噪、降采样等；
3. 特征提取：对预处理后的语音信号进行特征提取，如MFCC、LPC等；
4. 建立模型：使用各类机器学习算法建立语音识别模型，如HMM、DNN、CNN等；
5. 训练模型：使用大量语音数据对模型进行训练；
6. 测试模型：使用测试数据对模型进行测试，评估模型的性能。
实验结果：
通过实验我们成功实现了一个基于Python的语音识别系统。
该系统能够对人声进行实时识别，并输出对应的文本结果。
为了提高系统的准确率，我们使用了MFCC作为特征提取方法，并采用了HMM作为模型的训练和识别算法。
实验结果表明，该系统在大量语音数据的训练和测试下能够达到90%以上的准确率。
南邮数据结构实验报告
南邮数据结构实验报告实验目的，通过本次实验，我们旨在加深对数据结构的理解，掌握数据结构的基本操作和算法设计能力，提高对数据结构的应用能力和实际问题的解决能力。
一、实验内容。
1. 实验一，线性表的基本操作。
本次实验中，我们首先学习了线性表的基本概念和操作，包括插入、删除、查找等操作，并通过实际编程操作来加深对线性表的理解。
2. 实验二，栈和队列的应用。
在实验二中，我们通过实际编程操作来学习栈和队列的应用，包括中缀表达式转换为后缀表达式、栈的应用、队列的应用等内容。
3. 实验三，树和二叉树的基本操作。
实验三中，我们学习了树和二叉树的基本概念和操作，包括树的遍历、二叉树的建立和遍历等内容，并通过实际编程操作来加深对树和二叉树的理解。
4. 实验四，图的基本操作。
最后，我们学习了图的基本概念和操作，包括图的存储结构、图的遍历等内容，并通过实际编程操作来加深对图的理解。
二、实验过程。
在实验过程中，我们首先对实验内容进行了深入的学习和理解，掌握了数据结构的基本概念和操作方法。
然后，我们通过实际编程操作来加深对数据结构的理解，并通过调试和修改程序来提高对数据结构的应用能力和实际问题的解决能力。
在实验过程中，我们遇到了一些问题，但通过不懈的努力和团队合作，最终顺利完成了实验任务。
三、实验结果与分析。
通过本次实验，我们深入理解了数据结构的基本概念和操作方法，掌握了线性表、栈、队列、树、二叉树和图的基本操作，并通过实际编程操作加深了对数据结构的理解。
同时，我们也提高了对数据结构的应用能力和实际问题的解决能力，为今后的学习和工作打下了坚实的基础。
四、实验总结。
通过本次实验，我们不仅加深了对数据结构的理解，还提高了对数据结构的应用能力和实际问题的解决能力。
在今后的学习和工作中，我们将继续努力，不断提升自己的专业能力，为将来的发展打下坚实的基础。
以上就是本次实验的报告内容，谢谢！。
南邮算法实验报告
一、实验目的本次实验旨在通过实际操作，加深对算法理论知识的理解，提高算法设计与分析能力，培养解决实际问题的能力。
通过实验，使学生掌握以下内容：1. 理解常见算法的基本原理和实现方法；2. 掌握算法设计与分析的常用方法；3. 能够运用算法解决实际问题。
二、实验内容本次实验选择了以下两个算法进行实现和分析：1. 冒泡排序算法；2. 快速排序算法。
三、实验过程1. 冒泡排序算法（1）算法原理冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。
遍历数列的工作是重复地进行，直到没有再需要交换，也就是说该数列已经排序完成。
（2）实现步骤① 初始化一个布尔变量 swapped，用于判断是否发生交换；② 遍历数组，比较相邻的两个元素，如果前者大于后者，则交换它们的位置；③ 如果在一轮遍历中没有发生交换，则说明数组已经排序完成，退出循环；④ 重复步骤②和③，直到数组排序完成。
（3）代码实现```pythondef bubble_sort(arr):n = len(arr)for i in range(n):swapped = Falsefor j in range(0, n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j]swapped = Trueif not swapped:breakreturn arr```2. 快速排序算法（1）算法原理快速排序是一种分而治之的排序算法。
基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另一部分的所有数据要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
（2）实现步骤① 选择一个基准值（pivot），可以是数组的第一个元素、最后一个元素或中间元素；② 将数组分为两部分，一部分是小于基准值的元素，另一部分是大于基准值的元素；③ 对这两部分数据分别进行快速排序；④ 递归执行步骤①至③，直到数组排序完成。
数学实验报告南邮
实验名称：线性方程组的求解方法实验目的：1. 理解线性方程组的概念及其解法。
2. 掌握高斯消元法和克拉默法则求解线性方程组的方法。
3. 通过实验验证不同方法的计算效率和适用范围。
实验时间：2023年X月X日实验地点：南京邮电大学计算机实验室实验器材：1. 计算机2. 数学软件（如MATLAB、Mathematica等）3. 纸张和笔实验步骤：一、实验准备1. 确定实验所需线性方程组，例如：\[\begin{cases}2x + 3y - z = 4 \\-x + 2y + 3z = -1 \\3x - 2y + 4z = 5\end{cases}\]2. 熟悉高斯消元法和克拉默法则的原理。
二、实验实施1. 高斯消元法求解（1）将线性方程组转化为增广矩阵：\[\begin{bmatrix}2 &3 & -1 & | &4 \\-1 & 2 & 3 & | & -1 \\3 & -2 &4 & | & 5\end{bmatrix}\]（2）进行行变换，将增广矩阵转化为行最简形式：\[\begin{bmatrix}1 & 0 & 0 & | & 1 \\0 & 1 & 0 & | & 1 \\0 & 0 & 1 & | & 1\end{bmatrix}\]（3）根据行最简形式得到方程组的解：\(x = 1, y = 1, z = 1\)。
2. 克拉默法则求解（1）计算系数矩阵的行列式：\[D = \begin{vmatrix}2 &3 & -1 \\-1 & 2 & 3 \\3 & -2 & 4\end{vmatrix}\]（2）计算增广矩阵的行列式：\[D_x = \begin{vmatrix}4 & 3 & -1 \\-1 & 2 & 3 \\5 & -2 & 4\end{vmatrix}\]（3）计算\(D_y\)和\(D_z\)，分别对应\(x\)、\(y\)、\(z\)的系数矩阵和增广矩阵的行列式。
南京邮电大学实验报告模版
实验报告（ 2014 / 2015 学年第一学期）课程名称计算机操作系统实验名称虚构储存中页面置换算法的模拟实现实验时间2014 年 12 月19 日指导单位南京邮电大学指导教师崔衍学生姓名学院 (系) 物联网院班级学号专业网络工程实验报告实验名称虚构储存中页面置换算法的指导教师崔衍模拟实现实验种类上机实验实验学时4实验时间一、实验目的和要求目的：经过恳求页式储存管理中页面置换算法模拟设计，认识虚构储存技术的技术特色，掌握恳求页式储存管理的页面置换算法要求：(1)设计实现下边算法，并输出下述各样算法的命中率。
①先进先出的算法（FIFO）；②近来最少使用算法（LRR) ；③最正确裁减算法（OPT）先裁减最不常用的页地点。
(2)多次频频运转改良后的程序，察看并记录运转结果，并剖析原由。
二、实验环境 (实验设施 )二、实验原理及内容实验三#include <iostream.h>#include<stdlib.h>#include<conio.h>#include<stdio.h>#define Bsize 4typedef struct BLOCK// 申明一种新种类——物理块种类{int pagenum;// 页号int accessed;//接见字段，其值表示多久未被接见}BLOCK;int pc;// 程序计数器，用来记录指令的序号int n;// 缺页计数器，用来记录缺页的次数static int temp[320];// 用来储存320 条随机数BLOCK block[Bsize]; //定义一大小为 4 的物理块数组//*************************************************************void init( );// 程序初始化函数int findExist(int curpage);// 查找物理块中能否有该页面int findSpace( );// 查找能否有安闲物理块int findReplace( );// 查找应予置换的页面void display ( );// 显示void suijishu( );// 产生 320 条随机数 ,显示并储存到 temp[320] void pagestring( );// 显示调用的页面行列void OPT( );//OPT 算法void LRU( );// LRU 算法void FIFO( );//FIFO算法//*************************************************************void init( ){for(int i=0;i<Bsize;i++){block[i].pagenum=-1;block[i].accessed=0;pc=n=0;}}//-------------------------------------------------------------int findExist(int curpage){for(int i=0; i<Bsize; i++){if(block[i].pagenum == curpage )return i;// 检测到内存中有该页面，返回block 中的地点}return -1;}//-------------------------------------------------------------int findSpace( ){for(int i=0; i<Bsize; i++){if(block[i].pagenum == -1)return i;// 找到安闲的block ，返回 block 中的地点}return -1;}//-------------------------------------------------------------int findReplace( ){int pos = 0;for(int i=0; i<Bsize; i++){if(block[i].accessed >block[pos].accessed)pos = i;// 找到应予置换页面，返回BLOCK 中地点}return pos;}//-------------------------------------------------------------void display( ){for(int i=0; i<Bsize; i++){if(block[i].pagenum != -1){ printf(" %02d",block[i].pagenum);}}cout<<endl;}//-------------------------------------------------------------void suijishu( ){int flag=0;cin>>pc;cout<<"****** 依据要求产生的 320 个随机数： *******"<<endl;for(int i=0;i<320;i++){temp[i]=pc;if(flag%2==0) pc=++pc%320;if(flag==1) pc=rand( )% (pc-1);if(flag==3) pc=pc+1+(rand( )%(320-(pc+1)));flag=++flag%4;printf(" %03d",temp[i]);if((i+1)%10==0) cout<<endl;}}//-------------------------------------------------------------void pagestring( ){for(int i=0;i<320;i++){printf(" %02d",temp[i]/10);if((i+1)%10==0) cout<<endl;}}//-------------------------------------------------------------void OPT( ){int exist,space,position ;int curpage;for(int i=0;i<320;i++){if(i%100==0) getch( );pc=temp[i];curpage=pc/10;exist = findExist(curpage);if(exist==-1){space = findSpace ( );if(space != -1){block[space].pagenum = curpage;display( );n=n+1;}else{for(int k=0;k<Bsize;k++){for(int j=i;j<320;j++){if(block[k].pagenum!= temp[j]/10){block[k].accessed = 1000;}// 未来不会用，设置为一个很大数else{block[k].accessed = j;break;}}}position = findReplace( );block[position].pagenum = curpage;display( );n++;}}}cout<<" 缺页次数 :"<<n<<endl;cout<<" 缺页率 :"<<(n/320.0)*100<<"%"<<endl;}//-------------------------------------------------------------void LRU( ){int exist,space,position ;int curpage;for(int i=0;i<320;i++){if(i%100==0) getch( );pc=temp[i];curpage=pc/10;exist = findExist(curpage);if(exist==-1){space = findSpace( );if(space != -1){block[space].pagenum = curpage;display( );n=n+1;}else{position = findReplace( );block[position].pagenum = curpage;display( );n++;}}else block[exist].accessed = -1;// 恢复存在的并刚接见过的BLOCK 中页面accessed为 -1 for(int j=0; j<4; j++)}cout<<" 缺页次数 :"<<n<<endl;cout<<" 缺页率 :"<<(n/320.0)*100<<"%"<<endl;}//-------------------------------------------------------------void FIFO( ){int exist,space,position ;int curpage;for(int i=0;i<320;i++){if(i%100==0) getch( );pc=temp[i];curpage=pc/10;exist = findExist(curpage);if(exist==-1){space = findSpace( );if(space != -1){block[space].pagenum = curpage;display( );n=n+1;}else{position = findReplace( );block[position].pagenum = curpage;display( );n++;block[position].accessed--;}}for(int j=0; j<Bsize; j++)}cout<<" 缺页次数 :"<<n<<endl;cout<<" 缺页率 :"<<(n/320.0)*100<<"%"<<endl;}//*************************************************************void main( ){int select;cout<<" 请输入第一条指令号(0~320) ： ";suijishu( );cout<<"***** 对应的调用页面行列*******"<<endl;pagestring( );do{cout<<"****************************************"<<endl;cout<<"------1:OPT2:LRU 3:FIFO4:退出 -----"<<endl;cout<<"****************************************"<<endl;cout<<"请选择一种页面置换算法:";cin>>select;cout<<"****************************************"<<endl;init( );switch(select){case 1:cout<<"最正确置换算法OPT:"<<endl;cout<<"*****************"<<endl;OPT( );break;case 2:cout<<" 近来最久未使用置换算法LRU:"<<endl;cout<<"**************************"<<endl;LRU( );break;case 3:cout<<" 先进先出置换算法FIFO:"<<endl;cout<<"*********************"<<endl;FIFO( );break;default: ;}}while(select!=4); }实验结果：实验四Login 用户登录bool chklogin(char *users, char *pwd){int i;for(i=0; i<8; i++){if( (strcmp(users,usrarray[i].name)==0) && (strcmp(pwd,usrarray[i].pwd)==0)) return true;}return false;}Create创立文件int create(){temp=initfile(" ",0);cin>>temp->filename;cin>>temp->content;if(recent->child==NULL){temp->parent=recent;temp->child=NULL;recent->child=temp;temp->prev=temp->next=NULL;cout<<"文件成立成功 !"<<endl;}else{ttemp=recent->child;while(ttemp->next){ttemp=ttemp->next;if(strcmp(ttemp->filename,temp->filename)==0&&ttemp->isdir==0) {printf(" 对不起 ,文件已存在 !");return 1;}}ttemp->next=temp;temp->parent=NULL;temp->child=NULL;temp->prev=ttemp;temp->next=NULL;cout<<"文件成立成功 !"<<endl;}return 1;}int dir(){int i=0,j=0;temp=new fnode;temp=recent;if(temp!=root){cout<<"\ <DIR> "<<".."<<endl;i++;}if(temp->child==NULL){cout<<"Total: "<<" directors" <<i<<" files"<< j <<endl;return 1;}temp=temp->child;while(temp){if(temp->isdir){cout<<"<DIR>\ "<<temp->filename<<endl;i++;}else{cout<<"<FILE> "<<temp->filename<<endl;j++;}temp=temp->next;}cout<<"Total: "<<" directors" <<i<<"files"<< j <<endl;}Read读取文件int read(){char filename[FILENAME_LENGTH];cin>>filename;if(recent->child==NULL){cout<<"文件不存在 !"<<endl;return 1;}if(strcmp(recent->child->filename,filename)==0) {cout<<recent->child->content<<endl;return 1;}else{temp=recent->child;while(temp->next){if(strcmp(temp->next->filename,filename)==0) {cout<<temp->next->content<<endl;return 1;}}cout<<"文件不存在 !"<<endl;}}Write 写入文件int write(){char filename[FILENAME_LENGTH];cin>>filename;if(recent->child==NULL){cout<<"文件不存在 !"<<endl;return 1;}if(strcmp(recent->child->filename,filename)==0) {recent->child->isopen=1;//设置文件标志为翻开cin>>recent->child->content;recent->child->isopen=0;//设置文件标志为封闭cout<<"文件写入成功 !"<<endl;return 1;}elsetemp=recent->child;while(temp->next){if(strcmp(temp->next->filename,filename)==0){recent->child->isopen=1;//设置文件标志为翻开cin>>temp->next->content;recent->child->isopen=0;//设置文件标志为封闭cout<<"文件写入成功 !"<<endl;return 1;}}cout<<"文件不存在 !"<<endl;}}Del 删除int del(){char filename[FILENAME_LENGTH];cin>>filename;temp=new fnode;if(recent->child){temp=recent->child;while(temp->next && (strcmp(temp->filename,filename)!=0 || temp->isdir!=0)) temp=temp->next;if(strcmp(temp->filename,filename)!=0){cout<<"不存在该文件！ "<<endl;return 0;}}else{cout<<"不存在该文件！ "<<endl;return 0;}if(temp->parent==NULL){temp->prev->next=temp->next;if(temp->next)temp->next->prev=temp->prev;temp->prev=temp->next=NULL;else{if(temp->next)temp->next->parent=temp->parent;temp->parent->child=temp->next;}delete temp;cout<<"文件已删除 !"<<endl;}成立目录int mkdir(){temp=initfile(" ",1);cin>>temp->filename;if(recent->child==NULL){temp->parent=recent;temp->child=NULL;recent->child=temp;temp->prev=temp->next=NULL;}else{ttemp=recent->child;while(ttemp->next){ttemp=ttemp->next;if(strcmp(ttemp->filename,temp->filename)==0&&ttemp->isdir==1) {printf(" 对不起 ,目录已存在 !");return 1;}}ttemp->next=temp;temp->parent=NULL;temp->child=NULL;temp->prev=ttemp;temp->next=NULL;}return 1;切换目录int dir(){int i=0,j=0;temp=new fnode;temp=recent;if(temp!=root){cout<<"\ <DIR> "<<".."<<endl;i++;}if(temp->child==NULL){cout<<"Total: "<<" directors" <<i<<" files"<< j <<endl; return 1;}temp=temp->child;while(temp){if(temp->isdir){cout<<"<DIR>\ "<<temp->filename<<endl;i++;}else{cout<<"<FILE> "<<temp->filename<<endl;j++;} temp=temp->next;}cout<<"Total: "<<" directors" <<i<<"files"<< j <<endl; }四、实验小结（包含问题和解决方法、心得领会、建议与建议等）经过课程设计 ,加深了对操作系统的认识 ,认识了操作系统中各样资源分派算法的实现 ,特别是对虚构储存 ,页面置换有了深入的认识 ,并可以用高级语言进行模拟演示。
南邮数据结构实验一
南邮数据结构实验一数据结构是计算机科学中非常重要的一门课程，它研究的是如何组织和管理数据以便于高效地访问和操作。
在南京邮电大学的数据结构课程中，实验一是我们的第一个实验，旨在帮助我们熟悉基本的数据结构和算法。
任务一：线性表的实现线性表是一种最基本的数据结构，它由一组有序的元素组成，每个元素都有一个唯一的前驱和后继。
在这个实验中，我们需要实现一个线性表，并实现一些基本的操作，比如插入、删除和查找。
首先，我们需要定义一个数据结构来表示线性表。
一种常见的实现方式是使用数组，我们可以定义一个固定大小的数组来存储线性表的元素。
另一种方式是使用链表，我们可以定义一个节点结构来存储每个元素，并使用指针将这些节点连接起来。
接下来，我们需要实现线性表的插入操作。
插入操作可以在线性表的任意位置插入一个元素。
我们可以通过移动其他元素的位置来为新元素腾出空间，并将新元素插入到指定位置。
删除操作是将线性表中的一个元素移除。
我们可以通过将被删除元素的前驱和后继连接起来，跳过被删除元素来实现删除操作。
查找操作是在线性表中查找指定元素的位置。
我们可以遍历整个线性表，逐个比较元素的值，直到找到目标元素或者遍历完整个线性表。
任务二：栈的实现栈是一种特殊的线性表，它只允许在表的一端进行插入和删除操作。
栈的特点是先进后出，即最后插入的元素最先删除。
在这个实验中，我们需要实现一个栈，并实现一些基本的操作，比如入栈、出栈和判断栈是否为空。
与线性表类似，我们可以使用数组或链表来实现栈。
如果使用数组，我们需要定义一个指针来指示栈顶的位置。
如果使用链表，我们可以使用头指针来指示栈顶的位置。
入栈操作是将一个元素插入到栈顶。
我们可以将元素插入到数组的指定位置，或者创建一个新的节点并将其连接到链表的头部。
出栈操作是将栈顶的元素移除。
我们可以将栈顶的元素从数组中删除，或者将链表的头节点移除。
判断栈是否为空可以通过检查栈顶指针或者链表头指针是否为空来实现。
南邮计算物理实践报告设计
南京邮电大学实验报告课程名称：计算物理实践专业：应用物理学学号：姓名：完成日期：2014 年7月目录第一章简单物理实验的模拟及实验数据处理 (1)1.1问题描述 (1)1.2原理分析 (1)1.3Matlab程序仿真 (4)1.4Matlab仿真结果 (4)第二章方程组的解 (5)2.1问题描述 (5)2.2原理分析 (5)2.3流程图 (6)2.4Matlab程序仿真 (6)2.5Matlab仿真结果 (6)第三章静电场问题的计算 (7)3.1问题描述 (7)3.2原理分析 (7)3.3Matlab程序仿真 (9)3.4Matlab仿真结果 (9)第四章热传导方程和波动方程的差分解法 (10)4.1问题描述 (10)4.2原理分析 (10)4.3解题步骤 (13)4.4Matlab程序仿真 (13)4.5Matlab仿真结果 (13)第五章矩量法在静电场边值问题计算中的应用 (16)5.1问题描述 (16)5.2原理分析 (16)5.3Matlab程序仿真 (18)5.4Matlab仿真结果 (18)结束语 (19)参考文献 (20)附录一 (21)附录二 (22)附录三 (23)附录四 (25)附录五 (26)第一章 简单物理实验的模拟及实验数据处理1.1问题描述模拟电偶极子的场和等位线。
设在),(b a 处有电荷q +，在),(b a --处有电荷q -。
那么在电荷所在平面上任何一点的电势和场强分别为)11(4),(0-+-=r r qy x V πε，V E -∇=ρ。
其中2222)()(,)()(b y a x r b y a x r +++=-+-=-+，9019104πε=⨯。
又设电荷6210q -=⨯，5.1=a ，5.1-=b 。
1.2原理分析电偶极子是指一对等值异号的点电荷相距一微小距离所构成的电荷系统，它是一种常见的场源存在形式。
图（1）表示中心位于坐标系原点上的一个电偶极子，它的轴线与Z 轴重合，两个点电荷q 和-q 间的距离为L 。
南京邮电大学算法实现程序报告
算法实现程序设计报告一．问题描述输入N个点的坐标，判断这N个点能否构成一个凸多边形。
二．课题分析根据2点确定一条直线的原理,即y-y1/x-x1=y2-y1/x2-x1;移向得x(y2-y1)+y(x1-x2)-x1y2+x2y1, 设t= x(y2-y1)+y(x1-x2)-x1y2+x2y1,假如可组成凸多边形,且假设两点是图多边形一边,则把其他N-2点带入, 得到的t必均为正或均为负.由此可判断任意2点是否为凸多边形的一条边.由任意点开始寻找能够与其组成边的点,若按顺序能够找到N点则其为凸多边形,反之则不能.三．设计思路输入N个点,用二维数组存储这N个点, 定义real函数判断N个点是否能构成凸多边形,从第一个点开始能够找到N条满足函数tt的边则为图多边形.tt 为判断2点能否够成图多边形边的函数.四.处理流程图#include<stdio.h>#define N 4int tt(int p[][2],int a,int b){int temp[N],k=0;int t;int i;int j;for(i=0;i<N;i++){if(i==a||i==b){continue;}t=p[i][0]*(p[b][1]-p[a][1])+(p[a][0]-p[b][0])*p[i][1]-p[a][0]*p[b][1]+p[b][0]*p[a][1]; if(t==0)return 0;elseif(t>0)temp[k++]=1;elsetemp[k++]=-1;}for(j=1;j<k;j++){if(temp[0]!=temp[j]) return 0;}return 1;}int real(int p[][2]){int flag[N],m=0;int i,j;for(i=0;i<N;i++){flag[i]=0;}for( i=0;i<N;i++){for(j=1;j<N;j++){if(flag[j]) continue;if(tt(p,m,j)){flag[m]=1;m=j;break;}}}flag[m]=1;for(i=0;i<N;i++){if(flag[i]==0)return 0;}if(tt(p,0,m)) return 1;return 0;}void main(){int p[N][2];int i;printf("请输入这N个点坐标:\n");for(i=0;i<N;i++){printf("第%d个点坐标:",i+1);scanf("%d,%d",&p[i][0],&p[i][1]);printf("%d,%d\n",p[i][0],p[i][1]);}if (real(p))printf("能");elseprintf("不能");}六．程序测试记录：第一次：欢迎使用，本系统尚在试用阶段，有问题请与作者联系!请选择您的登陆方式( 1 :管理员 2 :普通用户)请输入您的用户名: zhaoyan请输入您的密码:haiyang您的用户名或密码有误，无法登陆!Press any key to continue第二次：欢迎使用，本系统尚在试用阶段，有问题请与作者联系! 请选择您的登陆方式( 1 :管理员 2 :普通用户)请输入您的用户名: yinjuan请输入您的密码:09005512请选择你要的操作：1:输入点的坐标2.运行程序3.判断能否构成凸多边形4:删除数据5:退出系统七．课程设计总结：算法实现的程序设计课是学校安排的自己动手的程序设计！自己发现问题、解决问题，使我对C和C++的操作有了进一步的掌握。
银行家算法等
银行家算法等课内实验报告课程名：操作系统任课教师：沈超专业：信息管理与信息系统学号：姓名：二○一六至二○一七年度第一学期南京邮电大学经济与管理学院《操作系统》课程实验第一次实验报告实验内容及基本要求：实验项目名称：调度系统的设计与实现实验类型：设计每组人数： 1实验内容及要求：实验内容:本次实验的主要内容是模拟调度系统的实现，包括高级、中级和低级调度的管理系统实现，调度算法的设计与实现以及银行家算法的设计设计与实现。
本次实验主要包括两部分内容：1、模拟具有三级调度的计算机系统进程运行过程，设计进程调度算法，将其存入进程文件中。
如：进程1：运行5秒后有3秒的I/O操作，之后有10秒的运行，结束。
可以写成：”p1:r5,io3,r3 e;”。
编程实现调度算法函数，设计优先级、时间片大小和并发进程个数，系统不断从进程文件中读出进程信息，选择一种进程调度算法，模拟进程的运行及调度过程，比较不同算法在周转时间和平均周转时间上的差异。
针对进程文件里面的数据为正常、缺项、格式不正确等各种情况，检测程序的执行结果。
2、理解安全性算法和银行家算法的核心机制：针对3类资源、5个进程的情况，设计相应的数据结构，分别表示每个进程占用各类资源的情况；编程实现安全性算法函数，编制主函数，动态输入资源的占用情况，进程的资源申请，调用安全性函数，实现银行家算法；输入可分配和不可分配的请求，测试系统的正确性。
实验要求:进程调度模拟程序根据一个进程调度文件，模拟进程的各种调度过程，用适合的表达方式表示出来。
银行家算法程序提供一个用户界面，可以在上边发出资源申请命令，系统应能给出是否可以接受申请，并且有结论输出。
思考:1、终端型进程流适合使用哪种调度算法？长批处理作业适合使用哪种调度算法？2、动态优先级调度算法的优先级变化率应该如何设置？实验结果：1.进程调度过程的模拟（1）概述选择一个调度算法，实现处理机调度。
设计要求：1）进程调度算法包括：先来先服务算法，时间片轮转算法，最高优先数优先优先算法，动态优先级算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验报告
（2013/2014学年第一学期）
课程名称算法分析与设计
实验名称分治策略
实验时间2015 年 3 月31 日指导单位计算机学院软件工程系
指导教师张怡婷
学生姓名班级学号
学院(系) 计算机软件专业软件工程
实验报告
void SortableList::Merge(int left,int mid,int right)//将两个有序子序列合并{
int *temp=new int[right-left+1];
int i=left,j=mid+1,k=0;
while ((i<=mid)&&(j<=right))
if(l[i]<=l[j])temp[k++]=l[i++];
else temp[k++]=l[j++];
while(i<=mid)temp[k++]=l[i++];
while(j<=right)temp[k++]=l[j++];
for(i=0,k=left;k<=right;)l[k++]=temp[i++];
}
排序结果：
2.快速排序：
}
}
排序结果：
思考：
1、在上述快速排序算法的执行过程中，跟踪程序的执行会发现，若初始输入序列递减有序，则调用Partition 函数进行分划操作时，下标i 向右寻找大于等于基准元素的过程中会产生下标越界，为什么？如何修改程序，可以避免这种情况的发生？
这是因为原有的程序在序列最右边未设置一个极大值作为哨兵，则下标i 在向右寻找大于等于基准元素的过程中，一直没有满足条件的元素值出现，就一直不会停止，直至越界。
所以只要在序列的最后预留一个哨兵元素，将它的值设为极大值∞就可以解决：
const int INF=2147483647; //定义一个极大值∞
l=new int[maxSize+1]; //预留最后一个哨兵的位置
10。