c语言程序设计实验报告内容

1、实验名称：计算出1000以内10个最大素数之和。

2、实验目的：熟练掌握if、if…else、if…else if语句和witch语句格式及使用方法，掌握if语句中的嵌套关系和匹配原则，利用if语句和switch语句实现分支选择结构。熟练掌握while语句、do…while语句和for语句格式及使用方法，掌握三种循环控制语句的循环过程以及循环结构的嵌套，利用循环语句实现循环结构。掌握简单、常用的算法，并在编程过程中体验各种算法的编程技巧。进一步学习调试程序，掌握语法错误和逻辑错误的检查方法。

3、实验内容：计算并输出1000以内最大的10个素数以及它们的和。

4、要求：在程序内部加必要的注释。 由于偶数不是素数，可以不考虑对偶数的处理。 虽然在1000以内的素数超过10个，但是要对1000以内不够10个素数的情况进行处理。 输出形式为：素数1＋素数2＋素数3＋…＋素数10＝总和值。

5、算法描述流程：Main函数：判断素数：

6、测试数据：分别输入1000、100、10测试。

7、运行结果：出现问题及解决方法：当素数个数小于10时的处理不够完善，考虑不够周全。学习耐心与细心不足，如scanf(“%d”,&n);中的“&”经常忘记。

8、编程思想不够发散，例如如何判断素数，只能想出2种方式（其中1种为参考教科书上内容）；在今后学习中应更多的动脑，综合运用所学。

9、基本功不够，如清屏clrscr()等函数用的不好，有时同样的问题多次犯，给实验课老师带来很大的麻烦。这说明我的知识不够广，有很多有用但不做考试要求的书中内容没有学好，认识程度不够深刻。就算以后C语言这门课程结束后，也应多看相关东西，多上机练习，才能真正从本质上提高自己。

10、物理实验报告 ·化学实验报告 ·生物实验报告 ·实验报告格式 ·实验报告模板

11、知识不够广泛，如VC＋＋60等程序，自己试了好一阵也不会用；说明我电脑水平还是不够，自学能力不够。已会的东西掌握的还是不够好。

12、实验心得：通过本次C语言上机实验，我对这个介于人类与非人类之间的计算机编程语言有了一定的体验。其间开心过、郁闷过、无奈过、彷徨过……随着实验的胜利成功与实验报告的胜利完成，有点微微的自豪感使人难忘。感谢高克宁老师的高标准、严要求，感谢实验课上小老师们的耐心指点，也感谢我在实验中经历过的点点滴滴……伴随着学习的深入，我发现高深的东西还有很多很多，等待着我自己去挖掘。对C语言，我会更加努力。

unsigned char counter;

sbit red_nb=P2^0;

void main()

{

TMOD=

TH0

TL0

ET0

TR0

while(1) //根据楼主所给，有4种状态

{

state1;

state2;

state3;

state4;

}

}

void timer0() interrupt 1 //定时器0

{

TH0=0x3c;

TL0=0xb0;

counter++;

}

void state1() //控制南北红灯亮，东西绿灯亮,30s

{

unsigned char temp = 30;

red_nb=1;

green_dx=1;

while(1)

{

if( counter>19){counter=0;temp--} //每次counter=20，即1s，temp自减

if(temp) break; //当temp为0时，即30秒,退出状态1，进入状态2

}

}

没经过测试，完全是5分诱惑不大。。

i=3时，s=s+a(3)1=0+4=4,j=10

i=2时，s=s+a(2)10=4+310=34,j=100

i=1时，s=s+a(1)100=34+2100=234,j=1000

i=0时，s=s+a(0)1000=234+11000=1234,j=10000

所以s是1234

动态规划解0-1背包：

#include<iostream>

using namespace std;

//显然定义为全局变量不好

const int item=3;//物品数量

const int max_wgt=10;//背包最大容量

int c[item+1][max_wgt+1];//从1…i…item物品中,背包剩余空间为0<=j<=max_wgt的最大价值

int w[item+1]={0,3,4,5};//物品质量

int vl[item+1]={0,4,5,6}; //物品价值

int knapbag()

{

for (int i=0;i<=item;i++)//初始化

{

for (int j=0;j<=max_wgt;j++)

{

c[i][j]=0;

}

}

//c(i,j)=max{c(i-1,j), c(i-1,j-w[i])+vl(i)}

for (int i=1;i<=item;i++)

{

for (int j=1;j<=max_wgt;j++)

{

if (w[i]<=j)

{

if (vl[i]+c[i-1][j-w[i]]>c[i-1][j])

{

c[i][j]=vl[i]+c[i-1][j-w[i]];//选择第i物品

}

else

c[i][j]=c[i-1][j];//不选择第i个物品

}

else

c[i][j]=c[i-1][j];//剩余容量不够

}//endfor

}//endfor

return c[item][max_wgt];//返回最大值

}

int main()

{

cout<<knapbag()<<endl;

return 0;

}

void trackback()//算出是由哪几个物品组成

{

int temp_wei=max_wgt;

int x[item+1]={0,0,0,0};

for (int i=item;i>0;i--)

{

if (c[i][temp_wei]==c[i-1][temp_wei])//最后一个肯定是最大价值的

{

x[i]=0;

}

else

{

x[i]=1;

temp_wei-=w[i];

}

}

for (int i=0;i<=item;i++)

{

if (x[i])

{

std::cout<<i<<",";

}

}

std::cout<<std::endl;

}

最长公共子序列：

最长公共子序列的定义是，一个数列z分别是已知数列的子序列（子序列不一定是连续序列，是在该序列中删去若干元素后得到的序列），且是所有符合此条件序列中最长的，则z成为最长公共子序列lcs(Longest Common Subsequences)。有些地方则说公共子串就是要求连续的子序列，有些地方则不是，这里要注意区分。下面是完整实现代码。

#include <iostream>

using namespace std;

void LCS_Length(char x,char y,int b,int m,int n)

{

//c[i][j]表示x[i-1],y[j-1]之前公共子序列的长度,i表示x数组前进，j表示y数组前进

//不用c[i][j]表示x[i],y[j]之前公共子序列的长度是因为需要使用c[0][0]来表示没有公共子序列，

//即c[0][0]恒等于0，因此c数组最大下标为c[m+1][n+1]

int c;

c=new int[m+1];

for( int i=0;i<m+1;i++)

c[i]=new int[n+1];

for(int i=0;i<m+1;i++)

c[i][0]=0;

for(int i=0;i<n+1;i++)

c[0][i]=0;

for(int i=1;i<=m;i++)

{

for(int j=1;j<=n;j++)

{

if(x[i-1]==y[j-1])//找到一个公共“字符”

{

c[i][j]=c[i-1][j-1]+1;//公共子序列的长度在原来的基础上加1

b[i][j]=0;//做一个辅助标志，表示要达到目前的长度，x，y数组均需“前进”一步

//即x[i-1]，y[j-1]都要作出贡献

}

//当前字符不相同，且x数组后退一步（即c[i-1][j]）比y数组后退一步（即c[i][j-1]）

//所得到的公共子序列的长度要长，隐含的意思是当前最长公共子序列可以不需要x[i-1]

else if(c[i-1][j]>=c[i][j-1])

{

c[i][j]=c[i-1][j];//当前最长公共子序列可以不需要x[i-1]

b[i][j]=-1;

}

//和上面分析类似

else

{

c[i][j]=c[i][j-1];//当前最长公共子序列可以不需要y[j-1]

b[i][j]=1;

}

}

}

for(int i=0;i<m+1;i++)

{

delete c[i];

c[i]=NULL;

}

delete []c;

c=NULL;

}

//打印结果

void Print_LCS(int b,char x,int i,int j)

{

if(i==0||j==0)

return ;

if(b[i][j]==0)

{

Print_LCS(b,x,i-1,j-1);

cout<<x[i-1];

}

else if(b[i][j]==-1)

Print_LCS(b,x,i-1,j);

else

Print_LCS(b,x,i,j-1);

}

int _tmain(int argc, _TCHAR argv[])

{

char x[]="ADAB";

char y[]="ADCA";

int m=strlen(x);

int n=strlen(y);

int b;

b=new int[m+1];

for( int i=0;i<m+1;i++)

b[i]=new int[n+1];

LCS_Length(x,y,b,m,n);

Print_LCS(b,x,m,n);

for(int i=0;i<m+1;i++)

{

delete b[i];

b[i]=NULL;

}

delete []b;

b=NULL;

return 0;

}

A算法

1启发式搜索

广度优先搜索和双向广度优先搜索都属于盲目搜索，这在状态空间不大的情况下是很合适的算法，可是当状态空间十分庞大时，它们的效率实在太低，往往都是在搜索了大量无关的状态结点后才碰到解答，甚至更本不能碰到解答。

搜索是一种试探性的查寻过程，为了减少搜索的盲目性引，增加试探的准确性，就要采用启发式搜索了。所谓启发式搜索就是在搜索中要对每一个搜索的位置进行评估，从中选择最好、可能容易到达目标的位置，再从这个位置向前进行搜索，这样就可以在搜索中省略大量无关的结点，提高了效率。

2A算法

A算法是一种常用的启发式搜索算法。

在A算法中，一个结点位置的好坏用估价函数来对它进行评估。A算法的估价函数可表示为：

f'(n) = g'(n) + h'(n)

这里，f'(n)是估价函数，g'(n)是起点到终点的最短路径值（也称为最小耗费或最小代价），h'(n)是n到目标的最短路经的启发值。由于这个f'(n)其实是无法预先知道的，所以实际上使用的是下面的估价函数：

f(n) = g(n) + h(n)

其中g(n)是从初始结点到节点n的实际代价，h(n)是从结点n到目标结点的最佳路径的估计代价。在这里主要是h(n)体现了搜索的启发信息，因为g(n)是已知的。用f(n)作为f'(n)的近似，也就是用g(n)代替g'(n)，h(n)代替h'(n)。这样必须满足两个条件：（1）g(n)>=g'(n)（大多数情况下都是满足的，可以不用考虑），且f必须保持单调递增。（2）h必须小于等于实际的从当前节点到达目标节点的最小耗费h(n)<=h'(n)。第二点特别的重要。可以证明应用这样的估价函数是可以找到最短路径的。

3A算法的步骤

A算法基本上与广度优先算法相同，但是在扩展出一个结点后，要计算它的估价函数，并根据估价函数对待扩展的结点排序，从而保证每次扩展的结点都是估价函数最小的结点。

A算法的步骤如下：

1）建立一个队列，计算初始结点的估价函数f，并将初始结点入队，设置队列头和尾指针。

2）取出队列头（队列头指针所指）的结点，如果该结点是目标结点，则输出路径，程序结束。否则对结点进行扩展。

3）检查扩展出的新结点是否与队列中的结点重复，若与不能再扩展的结点重复（位于队列头指针之前），则将它抛弃；若新结点与待扩展的结点重复（位于队列头指针之后），则比较两个结点的估价函数中g的大小，保留较小g值的结点。跳至第五步。

4）如果扩展出的新结点与队列中的结点不重复，则按照它的估价函数f大小将它插入队列中的头结点后待扩展结点的适当位置，使它们按从小到大的顺序排列，最后更新队列尾指针。

5）如果队列头的结点还可以扩展，直接返回第二步。否则将队列头指针指向下一结点，再返回第二步。

4八数码问题的A算法的估价函数

估价函数中，主要是计算h，对于不同的问题，h有不同的含义。那么在八数码问题中，h的含意是各什么？八数码问题的一个状态实际上是数字0~8的一个排列，用一个数组p[9]来存储它，数组中每个元素的下标，就是该数在排列中的位置。例如，在一个状态中，p[3]=7，则数字7的位置是3。如果目标状态数字3的位置是8，那么数字7对目标状态的偏移距离就是3，因为它要移动3步才可以回到目标状态的位置。

八数码问题中，每个数字可以有9个不同的位置，因此，在任意状态中的每个数字和目标状态中同一数字的相对距离就有99种，可以先将这些相对距离算出来，用一个矩阵存储，这样只要知道两个状态中同一个数字的位置，就可查出它们的相对距离，也就是该数字的偏移距离：

0 1 2 3 4 5 6 7 8

0 0 1 2 1 2 3 2 3 4

1 1 0 1 2 1 2 3 2 3

2 2 1 0 3 2 1 4 3 2

3 1 2 3 0 1 2 1 2 3

4 2 1 2 1 0 1 2 1 2

5 3 2 1 2 1 0 3 2 1

6 2 3 4 1 2 3 0 1 2

7 3 2 3 2 1 2 1 0 1

8 4 3 2 3 2 1 2 1 0

例如在一个状态中，数字8的位置是3，在另一状态中位置是7，那么从矩阵的3行7列可找到2，它就是8在两个状态中的偏移距离。

估价函数中的h就是全体数字偏移距离之和。

显然，要计算两个不同状态中同一数字的偏移距离，需要知道该数字在每个状态中的位置，这就要对数组p[9]进行扫描。由于状态发生变化，个数字的位置也要变化，所以每次计算h都沿线扫描数组，以确定每个数字在数组中的位置。为了简化计算，这里用一个数组存储状态中各个数字的位置，并让它在状态改变时随着变化，这样就不必在每次计算h时，再去扫描状态数组。

例如，某个状态中，数字5的位置是8，如果用数组r[9]存储位置，那么就有r[5]=8。

现在用数组r[9]存储当前状态的数字位置，而用s[9]存储目标状态的数字位置，那么当前状态数字i对目标状态的偏移距离就是矩阵中r[i]行s[i]列对应的值。

5A算法的类结构

A算法的类声明如下：

class TAstar:public TEight

{

public:

TAstar(){} //构造函数

TAstar(char fname); //带参数构造函数

virtual void Search(); //A搜索法

private:

int f,g,h; //估价函数

int r[Num]; //存储状态中各个数字位置的辅助数组

static int s[Num]; //存储目标状态中各个数字位置的辅助数组

static int e[]； //存储各个数字相对距离的辅助数组

void Printl(TList<TAstar> L); //成员函数，输出搜索路径

int Expend(int i); //成员函数，A算法的状态扩展函数

int Calcuf(); //成员函数，计算估价函数

void Sort(TList<TAstar>& L,int k); //成员函数，将新扩展结点按f从小到大

//顺序插入待扩展结点队列

int Repeat(TList<TAstar> &L); //成员函数，检查结点是否重复

};

int TAstar::s[Num],TAstar::e[NumNum];

TAstar::TAstar(char fname):TEight(fname)

{

for(int i=0;i<Num;)

{

r[p[i]]=i; //存储初始状态个个数字的位置

s[q[i]]=i++; //存储目标状态个个数字的位置

}

ifstream fin;

finopen("\Eightdtxt",ios::in | ios::nocreate);//打开数据文件

if(!fin)

{

cout<<"不能打开数据文件!"<<endl;

return;

}

for(i=0;i<NumNum;i++) //读入各个数字相对距离值

fin>>e[i];

finclose();

f=g=h=0; //估价函数初始值

}

void TAstar::Printl(TList<TAstar> L)

{

TAstar T=this;

if(Tlast==-1)

return;

else

{

T=LGetData(Tlast);

TPrintl(L);

TPrintf();

}

}

int TAstar::Expend(int i)

{

if(Extend(i)) //结点可扩展

{

int temp=r[p[r[0]]]; //改变状态后数字位置变化，存储改变后的位置

r[p[r[0]]]=r[0];

r[0]=temp;

return 1;

}

return 0;

}

int TAstar::Calcuf()

{

h=0;

for(int i=0;i<Num;i++) //计算估价函数的h

h+=e[Numr[i]+s[i]];

return ++g+h;

}

void TAstar::Sort(TList<TAstar>& L,int k)

{

int n=LGetlen();

for(int i=k+1;i<n;i++)

{

TAstar T=LGetData(i);

if(this->f<=Tf)

break;

}

LInsert(this,i);

}

int TAstar::Repeat(TList<TAstar> &L)

{

int n=LGetlen();

for(int i=0;i<n;i++)

if(LGetData(i)==this)

break;

return i;

}

void TAstar::Search()

{

TAstar T=this; //初始结点

Tf=TCalcuf(); //初始结点的估价函数

TList<TAstar> L; //建立队列

LAppend(T); //初始结点入队

int head=0,tail=0; //队列头和尾指针

while(head<=tail) //队列不空则循环

{

for(int i=0;i<4;i++) //空格可能移动方向

{

T=LGetData(head); //去队列头结点

if(Th==0) //是目标结点

{

TPrintl(L);//输出搜索路径

TPrint(); //输出目标状态

return; //结束

}

if(TExpend(i)) //若结点可扩展

{

int k=TRepeat(L); //返回与已扩展结点重复的序号 if(k<head) //如果是不能扩展的结点

continue; //丢弃

Tlast=head; //不是不能扩展的结点，记录父结点

Tf=TCalcuf(); //计算f

if(k<=tail) //新结点与可扩展结点重复

{

TAstar Temp=LGetData(k);

if(Tempg>Tg) //比较两结点g值

LSetData(T,k); //保留g值小的

continue;

}

TSort(L,head) ; //新结点插入可扩展结点队列 tail++; //队列尾指针后移

}

}

head++; //一个结点不能再扩展，队列头指针指向下一结点

}

}

n皇后问题

#include <iostreamh>

#include <mathh>

void Queue(int n)

{

for (i=1; i<=n; i++) //初始化

x[i]=0;

k=1;

while (k>=1)

{

x[k]=x[k]+1; //在下一列放置第k个皇后

while (x[k]<=n && !Place(k))

x[k]=x[k]+1; //搜索下一列

if (x[k]<=n && k= =n) { //得到一个解，输出

for (i=1; i<=n; i++)

cout<<x[i];

return;

}

else if (x[k]<=n && k<n)

k=k+1; //放置下一个皇后

else {

x[k]=0; //重置x[k]，回溯

k=k-1;

}

}

}

bool Place(int k) //考察皇后k放置在x[k]列是否发生冲突

{

for (i=1; i<k; i++)

if (x[k]= =x[i] | | abs(k-i)= =abs(x[k]-x[i]))

return false;

return true;

}

首先m1和n1未参与运算，数值不会变化的，还是16和24

然后是while循环，re=m nod n=16 mod 24=16

m=n=24

n=re=16

n不等于0，继续循环

re=m nod n=24 mod 16=8

m=n=16

n=re=8

n不等于0，继续循环

re=m nod n=16 mod 8=0

m=n=8

n=re=0

n等于0，终止循环

此时m=8

所以打印16 24 8

以上就是关于c语言程序设计实验报告内容全部的内容，包括:c语言程序设计实验报告内容、C语言程序设计编写一个交通红绿灯的控制，各位高手帮帮忙急！、Visual Basic程序设计实验解析志勇P103数组for循环步长负1等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！