算法之FTCS
[整理版]功课调剂三种算法fcfs,sjf,hrn
![[整理版]功课调剂三种算法fcfs,sjf,hrn](https://img.taocdn.com/s3/m/b3481849302b3169a45177232f60ddccda38e6e5.png)
作业调度三种算法FCFS,SJF,HRN#include "stdio.h"#define getjcb(type) (type*)malloc(sizeof(type))#define NULL 0int n=0,time=0;float eti,ewi;struct jcb{ char name[10]; /* 作业名 */char state; /* 作业状态 */int ts; /* 提交时间 */float super; /* 优先权 */int tb; /* 开始运行时间 */int tc; /* 完成时间 */float ti; /* 周转时间 */float wi; /* 带权周转时间 */int ntime; /* 作业所需运行时间 */ char resource[10]; /* 所需资源 */struct jcb *link; /* 结构体指针 */} *p,*q,*head=NULL;typedef struct jcb JCB;inital(){int i;printf("\nInput jcb num\n");scanf("%d",&n);printf("Input\nname\tts\tntime\tresource\n");for(i=0;i<n;i++){p=getjcb(JCB);scanf("%s\t%d\t%d\t%s",&p->name,&p->ts,&p->ntime,&p->resour ce);p->state='W';p->link=NULL;if(head==NULL) head=q=p;else{q->link=p;q=p;}}}void print(JCB *pr,int m){JCB *p;printf("\ntime=%d",time);if(m==3){printf("\nname\tstate\tts\tntime\tsuper\tsource\ttb\ttc\tti\twi\n");printf("%s\t%c\t%d\t%d\t%4.2f\t%s\t%d\t%d\t%4.2f\t%4.2f\n",pr->name,pr->state,pr->ts,pr->ntime,pr->super,pr->resource, pr->tb,pr->tc,pr->ti,pr->wi);}else {printf("\nname\tstate\tts\tntime\tsource\ttb\ttc\tti\twi\n" );printf("%s\t%c\t%d\t%d\t%s\t%d\t%d\t%4.2f\t%4.2f\n",pr->name,pr->state,pr->ts,pr->ntime,pr->resource,pr->tb,pr->tc,pr->ti,pr->wi);}p=head;do{if(p->state=='W')if(m==3){printf("%s\t%c\t%d\t%d\t%4.2f\t%s\n",p->name,p->state,p->ts,p->ntime,p->super,p->resource);}else{printf("%s\t%c\t%d\t%d\t%s\n",p->name,p->state,p->ts,p->ntime,p->resource);}p=p->link;}while(p!=NULL);p=head;do{if(p->state=='F')if(m==3){printf("%s\t%c\t%d\t%d\t%4.2f\t%s\t%d\t%d\t%4.2f\t%4.2f\n",p->name,p->state,p->ts,p->ntime,p->super,p->resource,p->tb, p->tc,p->ti,p->wi);}else{printf("%s\t%c\t%d\t%d\t%s\t%d\t%d\t%4.2f\t%4.2f\n",p->name,p->state,p->ts,p->ntime,p->resource,p->tb,p->tc,p-> ti,p->wi);}p=p->link;}while(p!=NULL);}void last(){eti/=n;ewi/=n;printf("\neti=%7.3f\tewi=%7.3f\n",eti,ewi);}super(){JCB *padv;padv=head;do{if(padv->state=='W'&&padv->ts<=time)padv->super=(float)(time-padv->ts+padv->ntime)/padv->ntime;padv=padv->link;}while(padv!=NULL);}void hrn(m){JCB *min;int i,iden;for(i=0;i<n;i++){p=min=head;iden=1;super();do{if(p->state=='W'&&p->ts<=time)if(iden){min=p;iden=0;}else if(p->super>min->super) min=p;p=p->link;}while(p!=NULL);if(iden) {i--;time++;printf("\ntime=%d:\tno JCB submib...wait...",time);if(time>1000){printf("\nruntime is too long...error...");getch();}}else{running(min,m);}}}void sjf(int m){JCB *min;int i,iden;for(i=0;i<n;i++){p=min=head;iden=1;do{if(p->state=='W'&&p->ts<=time)if(iden){min=p;iden=0;}else if(p->ntime<min->ntime) min=p;p=p->link;}while(p!=NULL) ;if(iden) {i--;printf("\ntime=%d:\tno JCB submib...wait...",time);time++;if(time>100){printf("\nruntime is toolong...error");getch();}}else{running(min,m);}}}fcfs(int m){int i,iden;printf("\n\nthe jcb is runing...");for(i=0;i<n;i++){p=head;iden=1;do{if(p->state=='W'&&p->ts<=time) iden=0;if(iden)p=p->link;}while(p!=NULL&&iden) ;if(iden) {i--;printf("\ntime=%d:\tno JCB submib...wait...",time);time++;if(time>100){printf("\nruntime is too long...error");getch();}}else{running(p,m);}}}running(JCB *p,int m){p->tb=time;p->state='R';p->tc=p->tb+p->ntime;p->ti=(float)(p->tc-p->ts);p->wi=(float)(p->ti/p->ntime);eti+=p->ti;ewi+=p->wi;print(p,m);time+=p->ntime;p->state='F';printf("\n%s has been finished!\npress any key to continue...\n",p->name);getch();}void runjcb(int m){printf("\n\nstart running jcb...");switch(m){case 1:fcfs(m);break;case 2:sjf(m);break;case 3:hrn(m);break;default:printf("\nrunjcb error...\n");exit();}}start(){int m;char str[100]="\nselectalgorithm\n1.FCFS\n2.SJF\n3.HRN\n" ;printf("%s",str);m=getch()-48;inital();if(1<=m&&m<=3) runjcb(m);else {printf("\nselect error!try again...\n");start();}last();}main(){start();printf("\nfinished!");getch();}。
车间调度算法
车间调度算法是指为了优化车间生产调度而设计的算法。
下面介绍几种常见的车间调度算法：先来先服务（First-Come, First-Served，FCFS）算法：
工作按照到达顺序排队执行，先到先服务。
缺点是没有考虑工作的执行时间和紧急程度，可能导致长作业时间和低效率。
最短作业优先（Shortest Job Next，SJN）算法：
按照工作的执行时间进行排序，选择执行时间最短的工作优先执行。
可以最大程度地减少平均等待时间和周转时间，但可能导致长作业等待时间过长。
最高优先级优先（Highest Priority First，HPF）算法：
给每个工作分配一个优先级，优先级高的工作优先执行。
可以根据工作的紧急程度进行调度，但可能导致低优先级工作长时间等待。
轮转法（Round Robin，RR）算法：
将时间划分为时间片，每个工作在一个时间片内执行一定的时间，然后切换到下一个工作。
公平地分配处理器时间，避免长作业占用时间过长，但可能导致响应时间较长。
最早截止时间优先（Earliest Deadline First，EDF）算法：
按照工作的截止时间进行排序，选择最早截止时间的工作优先执行。
可以确保紧急工作及时完成，但需要准确估计截止时间。
启发式算法：
基于经验和启发规则进行调度决策，如遗传算法、模拟退火算法等。
可以根据具体问题的特点和需求进行调度，但可能不保证获得最优解。
不同的车间调度算法适用于不同的生产环境和问题需求。
选择适合的算法需要考虑生产特点、工作性质、优先级和调度目标等因素，并综合考虑平均等待时间、周转时间、资源利用率、紧急程度等指标。
first集合和follow集合的求法
first集合和follow集合的求法
FIRST集合和FOLLOW集合的求法如下：
1、FIRST集合的求法：
直接收取：如果X是终结符或为空，则First(X) = {X}。
反复传送：如果X是非终结符，则First集合一直传送下去，直到遇到终结符。
第一个状态减去ε（即空字符串）后加入到First集合中。
注意传送时非终结符是否可以为空，如果可以为空，则看下一个字符。
对于形如“…UP…”（P是非终结符）的组合，把First(P)直接收入到First集合中。
遇到形如E →TE’这样的产生式时，先把First(T)放入First(E)，然后查看T是否能推导出ε（即空字符串）。
如果能，则把First(E’)放入First(E)，以此类推。
若T不能推出ε，则First(E)求完。
2、FOLLOW集合的求法：
对于文法的开始符号S，将识别符号“#”置于FOLLOW(S)中。
若存在产生式A →αBβ，则将First(β) - {ε}加至FOLLOW(B)中。
这里，First(β)表示β能推导出的第一个终结符或非终结符的集合，但要去掉ε。
如果β可以推导出ε，则将FOLLOW(A)加至FOLLOW(B)中。
这意味着，如果B有可能是最后一个符号，那么A的FOLLOW集合应该加入到B的FOLLOW集合中。
反复使用上述规则，直到所求FOLLOW集合不再增大为止。
以上是对FIRST集合和FOLLOW集合求法的简要概述。
在实际应用中，需要根据具体的文法和产生式进行具体的分析和计算。
FIFO(先进先出算法)
FIFO（先进先出算法）先进先出算法（First In, First Out，简称FIFO）是一种常见的调度算法，也是操作系统和计算机网络中广泛应用的一种策略。
该算法使用队列的数据结构来管理和调度任务，按照任务的到达顺序进行处理，最先到达的任务先被处理，后到达的任务则等待在队列中。
在操作系统中，FIFO算法常用于内存管理和磁盘调度。
在内存管理中，操作系统根据进程的到达时间将其放入内存中的任务队列。
而在磁盘调度中，操作系统按照文件请求的到达顺序来访问硬盘。
这样可以保证任务按照顺序进行处理，不会出现任务被跳过或产生乱序的情况。
FIFO算法的原理非常简单，每个任务到达时加入队列的尾部，任务执行时从队列的头部取出。
这样可以确保先到达的任务先被执行，队列中的任务按照FIFO的顺序依次进行处理。
例如，有三个任务A、B、C按照顺序到达队列，从头部开始取出任务进行处理，则A、B、C依次被处理，保证了任务执行的顺序性。
FIFO算法的优点是实现简单，性能稳定。
由于只需要维护一个任务队列，不需要根据任务的优先级或其他因素进行排序和调度，所以实现相对较简单。
同时，由于保证了任务的先后顺序，不会出现任务等待时间过长或任务被忽略的情况，因此性能相对稳定。
然而，FIFO算法也存在一些不足之处。
首先，FIFO算法对任务的响应时间和完成时间没有考虑或优化，导致任务的等待时间可能很长。
如果队列中有一个优先级较低但是任务大小较大的任务排在前面，后面的优先级较高但是任务大小较小的任务将长时间等待。
其次，FIFO算法不适用于长任务和短任务相互混合的场景，可能导致响应时间变长，影响系统的实时性和用户体验。
为了解决FIFO算法的一些不足，人们在实际应用中通常会对其进行一些改进。
例如，引入优先级调度算法，给不同的任务设置优先级，按照优先级高低进行任务调度。
另外，也可以通过时间片轮转算法，将任务划分为多个时间片，在每个时间片内循环进行任务调度，以提高任务的响应速度。
FCM算法及其推导过程_浙大Ra
c
c
• 对F函数求极值得最优化条件如下：
c ∂F = ( ∑ u ik − 1) = 0 ∂λ i =1
∂F = [m(uik )m−1 (dik )2 − λ] = 0 ∂uik
•
•
n ∂F n m = ∑(uik ) xk − v j ∑(uik )m = 0 ∂vi k =1 i =1
FCM算法
主要内容
• • • • FCM的思想 FCM算法的步骤 FCM应用在邮件分类 下一步计划
1.FCM的思想
• FCM（Fuzzy C-means）：模糊C均值算法 • 模糊聚类的目标函数：
J(UV) =∑∑ (uik )m(dik )2 ,
i=1 k=1 c n
（式1）
• 与C-means算法的区别正在于目标函数：
• 1.针对缺点1，…… • 2.针对缺点2，…… • 3.缺点3暂时不予考虑
• 浙大Ra
• 1.设定聚类数目c和参数m • 2.给出初始隶属度矩阵U（0） （U（0）各列元素之和应为1，在实验 程序给U（0）每一列随机赋予c-1个0,1个1） • 3.利用式8计算新的聚类中心Vj • 4.利用式7计算新的隶属度矩阵 （若分母存在中djk=0,则ujk=1，且 对i ≠j,uik=0） • 5.用一个矩阵范数比较两次迭代之间隶属度矩阵，如果 ‖U(k+1)-U(k)‖<=e 则停止迭代。
J (V ) = ∑
i =1 c xk ∈Vi
∑
( d ik 度矩阵,uik是第k个样本对于第i类的隶属度. dik2= ‖xk-vi‖2是样本xk与聚类中心（均值）vi的欧氏距离.
• FCM算法的约束条件：某一个样本对于各个聚 类的隶属度之和为1. • (式3) ∑ u =1 • 我们想要得到min{J(U,V)} min{J(U,V)} • min{J (U,V )} = min{∑ ∑(u ) (d ) } = ∑ {min[∑(u ) (d ) ]} （式4）
布鲁特福斯模式匹配算法
布鲁特福斯模式匹配算法布鲁特福斯模式匹配算法，听起来是不是很高大上？别担心，这不是某种外星科技，实际上它就是一个在字符串中查找子串的好帮手。
想象一下，你正在翻一本老书，想找到某个特定的词，翻来翻去，简直像大海捞针。
但是布鲁特福斯就像你的好朋友，能帮你轻松找到那个词。
说实话，这个算法的原理简单得让人意外，仿佛是把一块蛋糕切成了小块，容易得多。
我们得了解布鲁特福斯的基本操作。
这个算法的名字，听上去有点严肃，其实它就是在字符串里“蛮干”，不断地尝试每一个可能的位置，直到找到那个你想要的子串。
想想看，就像你在找丢失的钥匙，瞎翻一通，有时候是效率低下的，但结果总是让人安心。
你可以把它想象成一个精力旺盛的侦探，挨家挨户地问，直到找到那个关键证人，哈，这种感觉是不是很刺激？用这个算法找东西，基本上可以说是没什么捷径。
它会把字符串的每一个位置都试一遍。
你要找的子串可能在开头，也可能在结尾，甚至可能藏在中间的某个角落，谁知道呢？所以它就像一个执着的孩子，非要找到玩具才肯罢休。
虽然效率不高，但在某些情况下，布鲁特福斯能给你带来意想不到的惊喜。
对于小数据量来说，简直是个绝佳选择。
毕竟，没有什么能比找到你想要的东西更让人开心了。
不过，话说回来，这个算法在处理大数据量时，就显得有点捉襟见肘。
你试想一下，面对上百万个字符，如果每次都要试个遍，简直比登天还难。
大家都知道，时间就是金钱，谁也不愿意浪费在这种无效的操作上。
所以说，如果你想要追求极致的效率，布鲁特福斯可能不是你的最佳选择。
简直就像开着小电动车在高速公路上飞驰，速度上根本比不了那些跑车。
但是，我们不能因为一个小缺点就抛弃它。
布鲁特福斯也有它的独特魅力，尤其在某些情况下，完全能够胜任。
比如说，你在调试代码时，或者在处理一些小型文本，布鲁特福斯就像一位随叫随到的老友，给你省心不少。
它的实现也不复杂，简单明了，哪怕是初学者也能轻松搞定。
适合自己的才是最好的。
在计算机科学的海洋里，布鲁特福斯的确不是最耀眼的明星，但却是一颗朴实的明珠。
先来先服务和短作业优先调度算法
先来先服务调度算法和短作业优先调度算法
作业
提交 时间
运行 时间
开始 时间
1 8.00 2.00 8.00
1 8.00 2.00 8.00
2 8.50 0.50 10.00
2 8.50 0.50 10.30
3 9.00 0.10 10.50
3 9.00 0.10 10.00
4 9.50 0.20 10.60
可有效降低作业/进程的平均等待时间。 4
SJ(P)F缺点：
(1) 该算法对长作业不利，如作业C的周转时间由10增 至16，其带权周转时间由2增至3.1。更严重的是，如果有 一长作业(进程)进入系统的后备队列(就绪队列)，由于调度 程序总是优先调度那些(即使是后进来的)短作业(进程)，将 导致长作业(进程)长期不被调度。（不利长作业）
(2) 该算法完全未考虑作业的紧迫程度，因而不能保证 紧迫性作业(进程)会被及时处理。（不及时）
(3) 由于作业(进程)的长短只是根据用户所提供的估计 执行时间而定的，而用户又可能会有意或无意地缩短其作 业的估计运行时间，致使该算法不一定能真正做到短作业 优先调度。（不完全可靠）
5
调度算法练习题
6
4 9.50 0.20 10.10
先来先服务调度算法
平均周转时间
t = 1.725
平均带权周转时间 w = 6.875
完成 周转 带权周转 执行 时间 时间 时间 顺序
10.00 2.00
1
1
10.00 2.00
1
1
10.50 2.00
4
2
10.80 2.30 4.6
4
10.60 1.60 16
3
10.10 1.10 11
FCFS和SJF调度算法
以下参考的别人的：FCFS和SJF调度算法思想和实现算法算法思想:设计程序模拟进程的先来先效劳FCFS和短作业优先SJF调度过程。
假设有n个进程分别在T1, …,T n时刻到达系统，它们需要的效劳时间分别为S1, … ,S n。
分别采用先来先效劳FCFS和短作业优先SJF 进程调度算法进行调度，计算每个进程的完成时间，周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。
源程序:#include <iomanip.h>#include <iostream.h>staticconstint N=100;intarrivalTime[N];//到达时间intserviceTime[N];//效劳时间intfinishTime[N];//完成时间intWholeTime[N];//周转时间double WeightWholeTime[N];//带权周转时间double averageWT,averageWWT;//平均周转时间intserviceTime_SJF[N];int n=0;intnowTime=0;//记录当前时间inti;{cout<<"\n=========================FCFS调度算法=========================\n";for(i=0;i<n;i++){if(arrivalTime[i]>nowTime)nowTime=arrivalTime[i];nowTime+=serviceTime[i];finishTime[i]=nowTime;}for(inti=0;i<n;i++)WholeTime[i]=finishTime[i]-arrivalTime[i];for(inti=0;i<n;i++)WeightWholeTime[i]=(double)WholeTime[i]/(double)serviceTime[i];for(inti=0;i<n;i++){averageWT+=(double)WholeTime[i]/n;averageWWT+=(double)WeightWholeTime[i]/n;}}{cout<<"\n==========================SJF调度算法=========================\n";int min=0;nowTime=arrivalTime[0]+serviceTime[0];finishTime[0]=nowTime;serviceTime_SJF[0]=100;intallin=0,j,k;for(i=1;i<n;i++){k=1;min=0;if(allin==0){j=0;while(arrivalTime[j]<=nowTime&& j<n){j++;if(j>n)allin=1;}}elsej=n;j=j-1;while(k<=j){if(serviceTime_SJF[k]==0)k++;else{if(serviceTime_SJF[min]>serviceTime_SJF[k])min=k;k++;}}serviceTime_SJF[min]=0;nowTime+=serviceTime[min];finishTime[min]=nowTime;}for(inti=0;i<n;i++)WholeTime[i]=finishTime[i]-arrivalTime[i];for(inti=0;i<n;i++)WeightWholeTime[i]=(double)WholeTime[i]/(double)serviceTime[i];averageWT=0;averageWWT=0;for(inti=0;i<n;i++){averageWT+=(double)WholeTime[i]/n;averageWWT+=(double)WeightWholeTime[i]/n;}}void sortOn()//进程按照到达或者效劳时间进行排序{int temp;for(inti=0;i<n;i++)for(int k=0;k<n-i-1;k++)if(arrivalTime[k+1]<arrivalTime[k]){temp=arrivalTime[k+1];arrivalTime[k+1]=arrivalTime[k];arrivalTime[k]=temp;temp=serviceTime[k+1];serviceTime[k+1]=serviceTime[k];serviceTime[k]=temp;}}void input(){cout<<"请输入进程的个数：";cin>>n;cout<<endl;while(n>100||n<=0){cout<<"进程个数必须大于0且小于等于100！请重新输入进程个数"<<endl;}cout<<"请输入这"<<N<<"个进程的到达时间：\n\n";for(inti=0;i<n;i++)//设置N个进程的到达时间{int M;cin>>M;arrivalTime[i]=M;}cout<<endl;cout<<"请输入这"<<N<<"个进程的对应的效劳时间：\n\n";for(inti=0;i<n;i++)//设置N个进程的效劳时间{int M;cin>>M;serviceTime[i]=M;serviceTime_SJF[i]=M;}cout<<endl;cout<<"您输入的这"<<N<<"个进程的信息如下：\n\n";sortOn();//进程按照到达时间进行排序cout<<"进程名\t\t";for(inti=0;i<n;i++){char c=i+65;cout<<c<<"\t";}cout<<"\n到达时间\t";for(inti=0;i<n;i++)cout<<arrivalTime[i]<<"\t";cout<<"\n效劳时间\t";for(inti=0;i<n;i++)cout<<serviceTime[i]<<"\t";cout<<endl<<endl;}void output(){cout<<"进程名\t\t";for(inti=0;i<n;i++){char c=i+65;cout<<c<<"\t";}cout<<"平均\n到达时间\t";for(inti=0;i<n;i++)cout<<arrivalTime[i]<<"\t"; cout<<"\n效劳时间\t";for(inti=0;i<n;i++)cout<<serviceTime[i]<<"\t";cout<<"\n完成时间\t";for(inti=0;i<n;i++)cout<<finishTime[i]<<"\t";cout<<"\n周转时间\t";for(inti=0;i<n;i++)cout<<WholeTime[i]<<"\t";cout<<averageWT<<setprecision(3)<<"\n带权周转时间\t";for(inti=0;i<n;i++)cout<<WeightWholeTime[i]<<"\t";cout<<averageWWT<<setprecision(3)<<endl;}void main(){cout<<"\n\n========================FCFS和SJF调度算法======================\n\n";input();FCFS();output();//getchar();SJF();output();char c;cin>>c;getchar();}。
操作系统各种调度算法
操作系统各种调度算法⼀、批处理作业调度算法1.先来先服务调度算法First Come，First Served.（FCFS）:就是按照各个作业进⼊系统的⾃然次序来调度作业。
这种调度算法的优点是实现简单，公平。
其缺点是没有考虑到系统中各种资源的综合使⽤情况，往往使短作业的⽤户不满意，因为短作业等待处理的时间可能⽐实际运⾏时间长得多。
2.短作业优先调度算法shortest job first(SPF): 就是优先调度并处理短作业，所谓短是指作业的运⾏时间短。
⽽在作业未投⼊运⾏时，并不能知道它实际的运⾏时间的长短，因此需要⽤户在提交作业时同时提交作业运⾏时间的估计值。
3.最⾼响应⽐优先算法Hightest response-radio next(HRN)：FCFS可能造成短作业⽤户不满，SPF可能使得长作业⽤户不满，于是提出HRN，选择响应⽐最⾼的作业运⾏。
响应⽐=1+作业等待时间/作业处理时间。
4. 基于优先数调度算法Highest Possible Frequency(HPF)：每⼀个作业规定⼀个表⽰该作业优先级别的整数，当需要将新的作业由输⼊井调⼊内存处理时，优先选择优先数最⾼的作业。
5.均衡调度算法，即多级队列调度算法基本概念：作业周转时间（Ti）＝完成时间(Tei)－提交时间(Tsi)作业平均周转时间(T)＝周转时间/作业个数作业带权周转时间（Wi）＝周转时间/运⾏时间响应⽐＝（等待时间＋运⾏时间）/运⾏时间⼆、进程调度算法1.先进先出算法(FIFO)：按照进程进⼊就绪队列的先后次序来选择。
即每当进⼊进程调度，总是把就绪队列的队⾸进程投⼊运⾏。
2. 时间⽚轮转算法Round Robin(RR)：分时系统的⼀种调度算法。
轮转的基本思想是，将CPU的处理时间划分成⼀个个的时间⽚，就绪队列中的进程轮流运⾏⼀个时间⽚。
当时间⽚结束时，就强迫进程让出CPU，该进程进⼊就绪队列，等待下⼀次调度，同时，进程调度⼜去选择就绪队列中的⼀个进程，分配给它⼀个时间⽚，以投⼊运⾏。
冯诺依曼稳定性分析
冯诺依曼稳定性分析维基百科，自由的百科全书跳转到：导航, 搜索数值分析中, 冯诺依曼稳定性分析 (亦作傅立叶稳定性分析) 用于验证计算线性偏微分方程时使用特定有限差分法的数值稳定性[1]，该分析方法基于对数值误差的傅立叶分解。
1947年英国研究人员John Crank和Phyllis Nicolson在文章中对该方法进行了简要介绍[2]，尔后又出现在冯诺依曼合作的文章中[3]。
洛斯阿拉莫斯国家实验室对该方法进行了进一步发展。
[编辑]数值稳定性数值稳定性与数值误差密切相关。
使用有限差分方法进行计算时，若任意时间步的误差不会导致其后计算结果的发散，则可称该有限差分法是数值稳定的。
如果误差随着进一步计算降低最终消失，该算法被认为稳定；若误差在进计算中保持为常量，则认为该算法“中性稳定”。
但如果误差随着进一步计算增长，结果发散，则数值方法不稳定。
数值方法的稳定性可以通过冯诺依曼稳定性分析得到验证。
稳定性一般不易分析，特别是针对非线性偏微分方程。
冯诺依曼稳定性方法只适用于满足 Lax–Richtmyer 条件（Lax 等价定理）的某些特殊差分法：偏微分方程系统须线性，常系数，满足周期性边界条件，只有两个独立变量，差分法中最多含两层时间步[4]。
由于相对简单，人们常使用冯诺依曼稳定性分析代替其他更为详细的稳定性分析，用以估计差分方法中对容许步长的限制。
[编辑]方法描述冯诺依曼误差分析将误差分解为傅立叶级数。
为了描述此过程，考虑一维热传导方程空间网格间隔为L, 对网格作FTCS（Forward-Time Central-Space，时间步前向欧拉法，空间步三点中心差分) 离散处理，其中。
为离散网格上的数值解，用于近似此偏微分方程的精确解u(x,t) 。
定义舍入误差。
其中是离散方程 (1) 式的精确解，为包含有限浮点精度的数值解。
因为精确解满足离散方程, 误差亦满足离散方程[5]：此式将确定误差的递推关系。
方程 (1) 和 (2) 中，误差和数值解随时间具有一致的变化趋势。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include
#include
#include
void main()
{
int i,j=0;
FILE *fp1;
float N,k,a,b,c=0.0;
double temp1[99]={
0
};
double temp2[99]={
0
};
printf("请输入时间t=");
scanf("%f",&N);
printf("请输入时间步长l=");
scanf("%f",&k);
// 初始化温度数组，temp1[0]是T1，temp1[98]是T99
for(i=29;i<=69;i++)
{
temp1[i]=1.0;
}
for(i=70;i<=98;i++)
{
temp1[i]=10.0/3.0-10.0/3.0*(i+1)/100.0;
}
//矩阵迭代计算，temp1迭代一次，结果存入temp2；temp2结果再存入temp1，
依次循环
for(j=1;j<=(N*10000/k);j++)
{
for(i=1;i<=97;i++)
{
temp2[i]=temp1[i-1]*k+temp1[i]*(1-2.0*k)+temp1[i+1]*k;
}
temp2[0]=temp1[0]*(1-2.0*k)+temp1[1]*k;
temp2[98]=temp1[98]*(1-2.0*k)+temp1[97]*k;
for(i=0;i<=98;i++)
{
temp1[i]=temp2[i];
}
}
for(i=0;i<=98;i++)
{
printf("%0.16f\n",temp1[i]);
}
fp1 = fopen("b.txt","w");//写方式打开文件a.txt
for(i=0;i<=98;i++)
{
fprintf(fp1,"%0.16f\n",temp1[i]);
}
system("pause");
fclose(fp1);
}