最新c++动态分区分配算法模拟(操作系统课程设计)
c++动态分区分配算法模拟(操作系统课程设计)
学习操作系统和计算机网 络，了解计算机系统的工 作原理
参加编程比赛和项目实践， 提高解决问题的能力
关注行业动态和技术发展， 不断学习新知识和技能
感谢您的观看
汇报人：
算法性能评估
时间复杂度：O(n)
空间复杂度：O(1)
稳定性：稳定
适用场景：适用于动态分 区分配问题
模拟结果总结与反思
模拟结果：动态分区分配算法的性能表现 优点：提高了内存利用率，减少了内存碎片 缺点：增加了内存管理开销，可能导致内存碎片 改进方向：优化内存管理算法，提高内存利用率和性能
05 课程设计总结与展望优化目标Leabharlann 提高 算法的执行效率 和内存利用率
优化策略：采用 动态调整分区大 小、优化内存分 配策略等方法
优化效果：通过 优化，可以提高 算法的执行效率 和内存利用率， 降低内存碎片率， 提高系统的稳定 性和可靠性。
04 模拟结果分析
内存分配情况统计
内存分配次数：统 计模拟过程中内存 分配的次数
确定分区大小和数量
确定分区大小：根据需求确定分区大小，如1KB、2KB等 确定分区数量：根据需求确定分区数量，如10个、20个等 分区分配策略：采用最佳适应算法、最坏适应算法、首次适应算法等 分区合并策略：采用分区合并算法，如合并空闲分区、合并相邻空闲分区等
实现分区分配算法
初始化：设置分区表，记录每个分区的状态和位置 分配：根据请求大小，查找合适的分区 合并：将相邻的空闲分区合并为一个大分区 分割：将大分区分割为多个小分区 回收：释放不再使用的分区，将其加入空闲分区列表 维护：定期整理分区表，保持分区信息的准确性
实现内存回收函数
内存回收函数的作用：释放不再使用的内存空间，提高内存利用率 内存回收函数的实现：通过遍历内存块链表，找到空闲内存块，将其添加到空闲链表中 内存回收函数的调用：在程序运行过程中，当需要释放内存时，调用内存回收函数 内存回收函数的优化：通过改进算法，提高内存回收的效率和准确性
计算机操作系统课程设计报告《存储管理——动态分区分配算法的模拟》
《计算机操作系统》课程设计题目：—存储管理一一动态分区分配算法的模拟 _专业： _________ 软件工程_______________年级： __________ 2012级 ___________小组成员：_____________________________ 指导教师：______________________________ 时间：________________________________地点：________________________________2012年5月目录目录 (1)概述 (3)2. ................................................................................................................................ 课程设计任务及要求. (3)2.1 设计任务 (3)2.2 设计要求 (3)2.3 课程设计任务安排 (3)3. 算法及数据结构 (4)3.1 算法的总体思想（流程） (4)3.2 首次适应算法 (4)3.2.1 功能 (4)3.2.2 数据结构（包括变量的定义，要注释！） (4)323算法（流程图表示，或伪C表示） (5)3.3 循环首次适应算法 (6)3.3.1 功能 (6)3.3.2 数据结构 (6)3.3.3 算法 (7)3.4 最佳适应算法 (8)3.4.1 功能 (8)3.4.2 数据结构 (8)3.4.3 算法 (8)3.5 最坏适应算法 (10)3.5.1 功能 (10)3.5.2 数据结构 (10)3.5.3 算法 (11)4. 程序设计与实现 (12)4.1 程序流程图 (12)4.2 程序代码（要注释） (12)4.3 实验结果 (21)5. 结论 (23)6. 收获、体会和建议。
(23)A的总结： (23)B的总结： (23)7. 参考文献。
动态分区分配操作系统操作方法实验步骤
动态分区分配操作系统操作方法实验步骤1.引言1.1 概述概述部分：在计算机系统中，动态分区分配是一种重要的操作系统操作方法。
它是指在运行时根据进程的内存需求动态地将系统内存分配给进程，以实现内存资源的高效利用。
动态分区分配操作方法在现代操作系统中被广泛应用，例如Windows、Linux等。
通过合理的动态分区分配策略，可以提升系统的性能和资源利用率。
本文将对动态分区分配操作系统操作方法进行详细介绍和实验步骤的说明。
首先，我们将介绍动态分区分配的背景和意义，包括其在操作系统中的作用和应用场景。
其次，我们将详细讨论实验的具体步骤，包括如何进行动态分区分配操作、如何测试相关的性能指标等。
本文的目标是帮助读者了解动态分区分配操作系统操作方法的基本原理和实践技巧。
同时，通过实际操作和实验验证，读者将能够更好地理解动态分区分配的概念和操作过程，提升对操作系统的理解和应用能力。
在接下来的章节中，我们将分别介绍动态分区分配操作系统操作方法的背景和实验步骤，并给出相应的实例和案例分析。
最后，我们将对实验结果进行总结和展望，探讨动态分区分配操作方法的发展前景和可能的研究方向。
通过本文的阅读和实验操作，读者将能够对动态分区分配操作系统操作方法有一个全面的了解，为进一步研究和应用提供基础和指导。
同时，我们也欢迎读者对本文内容进行补充和扩展，以促进相关领域的进一步发展和应用。
1.2 文章结构文章结构部分的内容可以从以下角度进行描述：文章结构是指整篇文章的组织框架和内容安排。
合理的文章结构可以使读者更好地理解文章的主题和内容，帮助读者快速找到所需信息并形成完整的认识。
本文将按照以下结构进行论述：1. 引言：在引言部分，我们将对动态分区分配操作系统操作方法的背景和意义进行介绍，明确文章的目的和重要性。
2. 正文：正文是文章的核心部分，将分为两个要点进行叙述。
2.1 第一个要点：动态分区分配操作系统操作方法。
首先，我们将对动态分区分配的背景进行介绍，解释其在操作系统中的应用和意义。
动态分区分配方式的模拟
temp->prior=p->prior;
temp->next=p;
temp->data.address=p->data.address;
p->prior->next=temp;
p->prior=temp;
p->data.address=temp->data.address+temp->data.size;
{
if(Best_fit(ID,request)==OK) cout<<"分配成功！"<<endl;
else cout<<"内存不足，分配失败！"<<endl;
return OK;
}
else //默认首次适应算法
{
if(First_fit(ID,request)==OK) cout<<"分配成功！"<<endl;
void show()
{
cout<<"+++++++++++++++++++++++++++++++++++++++\n";
cout<<"+++主存分配情况+++\n";
实验五 动态分区分配算法的模拟
实验五动态分区分配算法的模拟一、实验目的1、加深操作系统内存管理过程的理解2、掌握内存分配算法的基本应用二、实验任务请同学们用C/C++实现一个完整的（可变）动态分区管理器，包括分配，回收，分区碎片整理等。
希望同学们实现如下功能：n 初始化功能：内存状态设置为初始状态。
n 分配功能：要求至少使用两种算法，用户可以选择使用。
n 回收功能：n 空闲块的合并：即紧凑功能，用以消除碎片。
当做碎片整理时，需要跟踪分配的空间，修改其引用以保证引用的正确性。
n 显示当前内存的使用状态，可以使用表格或图形。
三、实验指导1．基本思想动态分区是指系统不预先划分固定分区，而是在装入程序的时候划分内存区域，使得为程序分配的分区大小恰好等于该程序的需求量，且分区的个数是动态的。
显然动态分区有较大的灵活性，较之固定分区能获得好的内存利用率。
2．数据结构动态分区管理可以用两种数据结构实现，一种是已分配区表和空闲区表，也就是用预先定义好的系统空间来存放空间分配信息。
另一种也是最常用的就是空闲链表，由于对分区的操作是动态的，所以很难估计数据结构所占用的空间，而且空闲区表会占用宝贵的系统空间，所以提出了空闲链表的概念。
其特点是用于管理分区的信息动态生成并和该分区在物理地址上相邻。
这样由于可以简单用两个空闲块之间的距离定位已分配空间，不仅节约了系统空间，而且不必维持已分配空间的信息。
本实验是要做一个模拟程序，来模拟动态分区算法的分配和回收过程，并不是真正的去分配和回收内存。
基本的模拟方法有两种：1、先从内存中申请一块存储区，对这块存储区进行模拟的分配和回收活动。
2、不申请存储区，自己定义一块虚拟的存储区，对这块存储区进行模拟的分配和回收活动，分配和回收仅仅是对数据结构的修改而已。
程序代码：#include<iostream>using namespace std;int FreePartition[100];//空闲分区块数组int FirstPartition[100];//首次适应算法数组int CycleFirstPartition[100];//循环首次适应算法数组int BestPartition[100];//最佳适应算法数组int WorstPartition[100];//最坏适应算法数组int ProcessNeed[100];//每个作业的大小int PartitionNum,ProcessNum;//分区块数，作业数//首次适应算法void First(){int i,j;char str;for(i=0;i<PartitionNum;i++){FirstPartition[i]=FreePartition[i];}for(i=0;i<ProcessNum;i++)//找出第一块满足作业的分区for(j=0;j<PartitionNum;j++){if(ProcessNeed[i]>FirstPartition[j])continue;else{FirstPartition[j]-=ProcessNeed[i];//找到后把分区大小减去作业的大小 ? ? ? ? ? ? ?str='A'+i;cout<<"作业"<<str<<"在第"<<j+1<<"块分区中"<<endl;break;}}cout<<endl;cout<<"分配之后剩余情况："<<endl;?for(i=0;i<PartitionNum;i++)cout<<FirstPartition[i]<<" ";cout<<endl<<endl;}//循环首次适应算法void CycleFirst(){int i,j=1;char str;for(i=0;i<PartitionNum;i++){CycleFirstPartition[i]=FreePartition[i];}for(i=0;i<ProcessNum;i++)//for(j=0;j<PartitionNum;j++){j=j-1;while(j<PartitionNum)if(ProcessNeed[i]>CycleFirstPartition[j])//continue;j++;else{CycleFirstPartition[j]-=ProcessNeed[i];str='A'+i;cout<<"作业"<<str<<"在第"<<j+1<<"块分区中"<<endl; break;}//j++;//cout<<j<<" ";if(j==PartitionNum && i!=ProcessNum){i=-1;}}}cout<<endl;cout<<"分配之后剩余情况："<<endl;for(i=0;i<PartitionNum;i++)cout<<CycleFirstPartition[i]<<" ";cout<<endl<<endl;}//最佳适应算法void Best(){int i,j,k;char str;?for(i=0;i<PartitionNum;i++){BestPartition[i]=FreePartition[i];}for(i=0;i<ProcessNum;i++){k=0;for(j=0;j<PartitionNum;j++){//cout<<BestPartition[j]<<" ? "<<ProcessNeed[i]<<endl; if(BestPartition[j]>=ProcessNeed[i]){break;}}for(int n=0;n<PartitionNum;n++){if(BestPartition[n]<BestPartition[k] && BestPartition[n]>=ProcessNeed[i])//找最佳的 k=n;}BestPartition[k]-=ProcessNeed[i];str='A'+i;cout<<"作业"<<str<<"在第"<<j+1<<"块分区中"<<endl;}cout<<endl;cout<<"分配之后剩余情况："<<endl;for(i=0;i<PartitionNum;i++)cout<<BestPartition[i]<<" ";cout<<endl<<endl;}//最坏适应算法void Worst(){int i,j,k;char str;for(i=0;i<PartitionNum;i++){WorstPartition[i]=FreePartition[i];}for(i=0;i<ProcessNum;i++){k=0;for(j=0;j<PartitionNum;j++){if(WorstPartition[j]>WorstPartition[k])//找到最大的分区k=j;}WorstPartition[k]-=ProcessNeed[i];str='A'+i;cout<<"作业"<<str<<"在第"<<j+1<<"块分区中"<<endl;}cout<<endl;cout<<"分配之后剩余情况："<<endl;for(i=0;i<PartitionNum;i++)cout<<WorstPartition[i]<<" ";cout<<endl<<endl;}void main(){int i;cout<<"输入分区块数："<<endl;cin>>PartitionNum;cout<<"输入每个分区的大小："<<endl;for(i=0;i<PartitionNum;i++)cin>>FreePartition[i];cout<<"输入作业数："<<endl;cin>>ProcessNum;cout<<"输入每个作业的大小："<<endl;for(i=0;i<ProcessNum;i++)cin>>ProcessNeed[i];cout<<"------------首次适应算法-----------------"<<endl; First();cout<<"------------循环首次适应算法-------------"<<endl; ?CycleFirst();cout<<"------------最佳适应算法-----------------"<<endl; Best();cout<<"------------最坏适应算法-----------------"<<endl; Worst();}。
计算机操作系统实验报告动态分区分配方式的模拟
计算机操作系统实验报告姓名：班级：学号：题目：动态分区分配方式的模拟实习内容简要描述本次实验要完成两部分内容：一是用C语言实现对采用首次适应算法和最佳适应算法的动态分区分配过程ALLOCo和回收过程FREE（）,其中空闲分区由空闲分区链来管理，进行分配时，系统优先使用空闲区底端空间。
二是假设初始状态下，可用内存空间为640KBO按照题目要求的作业顺序，以及各个作业分配和回收的内存空间。
分别采用首次适应法和最佳适应法，对内存进行分配和回收，要求每次分配和回收后显示空闲内存分区链的情况。
实验分析算法介绍本次实验通过用C语言进行编程并调试、运行，形象地表现出动态分区的分配方式，直观地展现了首次适应算法和最佳适应算法对内存的释放和回收方式之间的区别。
加深了我们对两种算法优缺点的理解，帮助我们了解一些数据结构和分配算法，进一步加深我们对动态分区存储器管理方式及其实现过程的理解。
主要的问题在于，如何解决两种算法对内存的释放和回收空间的表示。
动态分区分配：又称为可变分区分配，这种分配方式并不事先先将主存划分成一块块的分区，而是在作业进入主存时，根据作业的大小动态地建立分区。
并使分区的大小正好适应作业的需要。
因此系统中分区的大小是可变的，分区的数目也是可变的。
分区分配算法：（两者的空闲块链接方式不冋）①首次适应法：为作业选择分区时总是按地址从高到低搜索，只要找到可以容纳该作业的空白块，就把该空白块分配给该作业。
特点：优先利用内存中底地址部分的空闲分区（将所有空闲区，按其地址递增的顺序链接）②最佳适应算法：接到内存申请时，在空闲块表中找到一个不小于请求的最小空块进行分配；为作业选择分区时总是寻找其大小最接近于作业所要求的存储区域。
特点：用最小空间满足要求（将所有空闲区，按其大小递增的顺序联接成空闲区链）结果分析(思考题解答；错误原因分析)间的分配和回收。
思考题解答：1、首次适应算法分配时从表头指针开始查找可利用空间表，将找到的第一个大小不小于“请求”的空闲块的一部分分配给用户。
(完整word版)动态分区分配方式模拟
使用动态分区分配方式的模拟1内容（1）用C语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc( )和回收过程free( )。
其中，空闲分区通过空闲分区链来管理：在进行内存分配时，系统优先使用空闲区低端的空间。
（2）假设初始状态下，可用的内存空间为640KB，并有下列的请求序列：•作业1申请130KB。
•作业2申请60KB。
•作业3申请100KB。
•作业2释放60KB。
•作业4申请200KB。
•作业3释放100KB。
•作业1释放130KB。
•作业5申请140KB。
•作业6申请60KB。
•作业7申请50KB。
•作业6释放60KB。
请分别采用首次适应算法和最佳适应算法，对内存块进行分配和回收，要求每次分配和回收后显示出空闲分区链的情况。
2、示例程序：//Tittle: 使用动态分区算法的模拟//author: XuYongzhen#include <stdio.h>#include <stdlib.h>#include <malloc.h>#include <iostream>using namespace std;typedef struct DuLNode{struct DuLNode *prior;struct DuLNode *next;int address;int jsize;int jnumber;//显示分区被那个作业占用，显示零则为空闲分区；}DuLNode,*DuLinkList ;void CreatList(DuLinkList &L){DuLinkList p=(DuLinkList)malloc(sizeof(DuLNode));L->next=p;L->jnumber=100;//为释放头结点后面的结点空间做统一化处理p->prior=L;p->next=NULL;p->jsize=600;p->address=0;p->jnumber=0;}void RequestList(DuLinkList &L,int job,int size){cout<<"作业"<<job<<"申请"<<size<<"KB的空间"<<endl;DuLinkList p=L->next;while((p->jnumber>0||p->jsize<size)&&p)p=p->next;if(p==NULL)cout<<"没有适合的空间分配"<<endl;else{DuLinkList s=(DuLinkList)malloc(sizeof(DuLNode));s->prior=p->prior;p->prior->next=s;s->next=p;p->prior=s;s->jnumber=job;s->jsize=size;s->address=p->address;p->address=p->address+s->jsize;p->jsize=p->jsize-s->jsize;DuLinkList t=L->next;while(t){if(t->jnumber==0)cout<<"空闲分区：始址="<<t->address<<"大小="<<t->jsize<<endl;elsecout<<"已分配的分区：作业号="<<t->jnumber<<"始址="<<t->address<<"大小="<<t->jsize<<endl;t=t->next;}//whilecout<<endl;}//else}//RequestListvoid FreeList(DuLinkList &L,int job){cout<<"作业"<<job<<"释放"<<endl;DuLinkList p=L->next;while(p->next&&p->jnumber!=job)p=p->next;if(p->prior->jnumber==0 && p->next->jnumber==0){//p的前后都是空闲分区,则合并三者DuLinkList s=p->next;DuLinkList q=p->prior;p->prior->next=p->next;p->next->prior=p->prior;s->prior->next=s->next;s->next->prior=p->prior;q->jsize=p->jsize+s->jsize+q->jsize;}if(p->prior->jnumber==0 && p->next->jnumber!=0){//回收区与插入点的前一个分区相临接DuLinkList q=p->prior;p->prior->next=p->next;p->next->prior=p->prior;q->jsize=p->jsize+q->jsize;}if(p->prior->jnumber!=0 && p->next->jnumber==0){//回收区与插入点的后一个分区相临接DuLinkList q=p->next;p->prior->next=p->next;p->next->prior=p->prior;q->address=p->address;q->jsize=p->jsize+q->jsize;}if(p->prior->jnumber!=0 && p->next->jnumber!=0)//回收区去插入点前后的两个空闲分区都不相临接p->jnumber=0;DuLinkList t=L->next;while(t){if(t->jnumber==0)cout<<"空闲分区：始址="<<t->address<<"大小="<<t->jsize<<endl;elsecout<<"已分配的分区：作业号="<<t->jnumber<<"始址="<<t->address<<"大小="<<t->jsize<<endl;t=t->next;}cout<<endl;}void main(){DuLinkList L=(DuLinkList)malloc(sizeof(DuLNode));CreatList(L);RequestList(L,1,130);RequestList(L,2,60);RequestList(L,3,100);FreeList(L,2);RequestList(L,4,200);FreeList(L,3);FreeList(L,1);RequestList(L,5,140);RequestList(L,6,60);RequestList(L,7,50);FreeList(L,6);}。
动态分区分配课程设计
动态分区分配课程设计一、课程目标知识目标：1. 让学生理解动态分区分配的概念和原理；2. 掌握动态分区分配算法，如首次适应算法、最佳适应算法等；3. 了解内存碎片产生的原因及解决方法。
技能目标：1. 培养学生运用动态分区分配算法解决实际问题的能力；2. 提高学生分析、设计、优化内存分配方案的能力；3. 培养学生运用编程语言实现动态分区分配算法的能力。
情感态度价值观目标：1. 培养学生对计算机操作系统内存管理知识的兴趣和热情；2. 培养学生具备良好的团队合作精神和沟通能力；3. 培养学生具备解决问题的信心，敢于面对挑战。
分析课程性质、学生特点和教学要求：本课程为计算机操作系统内存管理部分，具有理论性和实践性。
学生为高中年级，具备一定的计算机基础和逻辑思维能力。
教学要求注重理论与实践相结合，培养学生的动手能力和实际应用能力。
课程目标分解：1. 通过讲解和案例分析，使学生理解动态分区分配的基本概念和原理；2. 通过课堂演示和实验操作，使学生掌握动态分区分配算法；3. 通过分组讨论和课后作业，培养学生分析、设计、优化内存分配方案的能力；4. 通过编程实践，提高学生运用编程语言实现动态分区分配算法的能力；5. 通过课堂互动和课后反馈，激发学生对计算机操作系统内存管理知识的兴趣，培养良好的团队合作精神和沟通能力。
二、教学内容1. 动态分区分配概念及原理- 内存分配方式概述- 动态分区分配的特点- 动态分区分配的内存管理策略2. 动态分区分配算法- 首次适应算法- 最佳适应算法- 最坏适应算法- 邻近适应算法3. 内存碎片问题及解决方法- 内存碎片的定义- 内存碎片产生的原因- 解决内存碎片的方法4. 动态分区分配编程实践- 编程语言选择（如C语言）- 动态分区分配算法的编程实现- 内存分配与回收功能的实现5. 内存分配案例分析- 案例一：基于首次适应算法的内存分配- 案例二：基于最佳适应算法的内存分配- 案例分析及讨论教学大纲安排：第一课时：动态分区分配概念及原理第二课时：动态分区分配算法第三课时：内存碎片问题及解决方法第四课时：动态分区分配编程实践（上）第五课时：动态分区分配编程实践（下）第六课时：内存分配案例分析及总结教学内容与教材关联性：本章节教学内容紧密结合教材中关于计算机操作系统内存管理部分的内容，确保学生能够掌握动态分区分配的相关知识，提高实践操作能力。
操作系统-实验四动态分区分配算法源代码最全(可编辑)
操作系统-实验四动态分区分配算法源代码最全（可编辑）实验四操作系统-动态分区分配算法萨斯的发生的v设计程序模拟四种动态分区分配算法:首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。
假设内存中空闲分区个数为n,空闲分区大小分别为P1, … ,Pn,在动态分区分配过程中需要分配的进程个数为m(m?n),它们需要的分区大小分别为S1, … ,Sm,分别利用四种动态分区分配算法将m个进程放入n个空闲分区,给出进程在空闲分区中的分配情况。
程序要求如下:1)利用首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法四种动态分区分配算法模拟分区分配过程。
2)模拟四种算法的分区分配过程,给出每种算法进程在空闲分区中的分配情况。
3)输入:空闲分区个数n,空闲分区大小P1, … ,Pn,进程个数m,进程需要的分区大小S1, … ,Sm,算法选择1-首次适应算法,2-循环首次适应算法,3-最佳适应算法,4-最坏适应算法。
4)输出:最终内存空闲分区的分配情况。
代码实现:#include#include#includeusing namespace std;const int Number100; int FreePartition[Number];//空闲分区大小 int FirstPartition[Number];//1-首次适应算法 intCycleFirstPartition[Number];//2-循环首次适应算法 intBestPartition[Number];//3-最佳适应算法 int WorstPartition[Number];//4-最坏适应算法 int ProcessNeed[Number];//进程需要的分区大小 int PartitionNum,ProcessNum; char ProcessName[Number];//进程名char ProcessPartition[Number];//进程分配的序列 int Partition[Number]; char str[Number][Number]; void FirstFitint n,int m; void NextFitintn,int m; void BestFitint n,int m; void WorstFitint n,int m; voidPrintint n, int m; void Print2int n, int m; //void FirstFitint n, int m cout"选择了首次适应算法!"endl;coutendl;int i,j,k0;fori0; in; i++FirstPartition[i] FreePartition[i]; forj0; jm; j++fori0; in; i++ifProcessNeed[j]FirstPartition[i] ProcessPartition[j]i;//str[i][k] ProcessName[j];FirstPartition[i] FirstPartition[i]-ProcessNeed[j];break;Printn,m;cout"空间序号:"" ";fori0; in; i++cout"|"setwm-1"空间"i+1;coutendl;cout"分区大小:"" ";fori0; in; i++cout"|"setwmsetiosflagsios::leftFreePartition[i];coutendl;cout"剩余分区大小:";fori0; in; i++cout"|"setwmsetiosflagsios::leftFirstPartition[i];coutendl;Print2n,m;void NextFitint n, int m cout"选择了循环首次适应算法!"endl; coutendl;int i,j,flag0;fori0; in; i++CycleFirstPartition[i] FreePartition[i];forj0; jm; j++foriflag; in; i++ifProcessNeed[j]CycleFirstPartition[i]ProcessPartition[j]i; CycleFirstPartition[i] CycleFirstPartition[i]-ProcessNeed[j];flag i+1;ifin-1flag0;break;Printn,m;cout"空间序号:"" ";fori0; in; i++cout"|"setwm-1"空间"i+1;coutendl;cout"分区大小:"" ";fori0; in; i++cout"|"setwmsetiosflagsios::leftFreePartition[i]; coutendl;cout"剩余分区大小:";fori0; in; i++cout"|"setwmsetiosflagsios::leftCycleFirstPartition[i]; coutendl;Print2n,m;void BestFitint n, int mcout"选择了最佳适应算法!"endl;coutendl;int i,j,flag0,temp,id0,flag10; fori0; in; i++ BestPartition[i] FreePartition[i]; whileflag1mflag 0;fori0; in; i++Partition[i]0;fori0; in; i++ifProcessNeed[flag1]BestPartition[i] Partition[flag]i; flag + 1;temp BestPartition[Partition[0]]; id Partition[0]; fori1;iflag; i++ iftemp BestPartition[Partition[i]] temp BestPartition[Partition[i]];id Partition[i];BestPartition[id]BestPartition[id]-ProcessNeed[flag1];ProcessPartition[flag1]id; flag1 + 1;Printn,m;cout"空间序号:"" ";fori0; in; i++cout"|"setwm-1"空间"i+1;coutendl;cout"分区大小:"" ";fori0; in; i++cout"|"setwmsetiosflagsios::leftFreePartition[i]; coutendl;cout"剩余分区大小:";fori0; in; i++cout"|"setwmsetiosflagsios::leftBestPartition[i]; coutendl;Print2n,m;void WorstFitint n, int mcout"选择了最坏适应算法!"endl;coutendl;int i,j,flag0,temp,id0,flag10;fori0; in; i++WorstPartition[i] FreePartition[i];whileflag1mflag 0;fori0; in; i++Partition[i]0;fori0; in; i++ifProcessNeed[flag1]WorstPartition[i]Partition[flag]i;flag + 1;temp WorstPartition[Partition[0]]; id Partition[0]; fori1;iflag; i++ ifWorstPartition[Partition[i]] temp temp WorstPartition[Partition[i]];id Partition[i];WorstPartition[id]WorstPartition[id]-ProcessNeed[flag1];ProcessPartition[flag1]id; flag1 + 1;Printn,m;cout"空间序号:"" ";fori0; in; i++cout"|"setwm-1"空间"i+1;coutendl;cout"分区大小:"" ";fori0; in; i++cout"|"setwmsetiosflagsios::leftFreePartition[i];coutendl;cout"剩余分区大小:";fori0; in; i++cout"|"setwmsetiosflagsios::leftWorstPartition[i];coutendl;Print2n,m;void choiceint n, int m int intput;cout"\n请选择:1.首次适应算法 2.循环首次适应算法 3.最佳适应算法 4. 最坏适应算法:"endl;cinintput;coutendl;switchintputcase 1:FirstFitn,m;choicen,m;break;case 2:NextFitn,m;choicen,m;break;case 3:BestFitn,m;choicen,m;break;case 4:WorstFitn,m; choicen,m;break;coutendl;void Printint n, int mint j;cout"进程名:";forj0; jm; j++ cout"|"setwmsetiosflagsios::leftProcessName[j]; coutendl;cout"进程分区大小:";forj0; jm; j++ cout"|"setwmsetiosflagsios::leftProcessNeed[j]; coutendl;cout"分配结果:"endl;void Print2int n, int m int i,j;fori0; in; i++forj0; jm; j++str[i][j] 0;cout"进程分配分区:";fori0; in; i++int k0;forj0; jm; j++ifProcessPartition[j]i str[i][k] ProcessName[j];k + 1;fori0; in; i++cout"|";forj0; jm; j++coutsetw1str[i][j]; coutendl;//void mainifstream in"yin.txt"; int n,m;int i,j;inn;fori0; in; i++ inFreePartition[i]; inm;forj0; jm; j++ inProcessName[j]; forj0; jm; j++ inProcessNeed[j]; choicen,m;运行结果:。
c++动态分区分配算法模拟(操作系统课程设计)
课程设计课程设计名称：操作系统课程设计专业班级：学生姓名：学号：指导教师：课程设计时间：6月13日-——6月17日计算机科学专业课程设计任务书学生姓名马飞扬专业班级学号题目动态分区分配方式的模拟1课题性质其它课题来源自拟课题指导教师同组姓名主要内容1）用C语言实现采用首次适应算法的动态分区分配过程alloc()和回收过程free()。
其中，空闲分区通过空闲分区链表来管理，在进行内存分配时，系统优先使用空闲区低端的空间。
2）假设初始状态如下，可用的内存空间为640KB，并有下列的请求序列；作业1申请130KB；作业2申请60KB；作业3申请100KB；作业2释放60KB；作业4申请200 KB；作业3释放100 KB；作业1释放130 KB；作业5申请140 KB；作业6申请60 KB；作业7申请50KB；作业6释放60 KB请采用首次适应算法进行内存块的分配和回收，同时显示内存块分配和回收后空闲内存分区链的情况。
任务要求了解动态分区分配中使用的数据结构和分配算法，并进一步加深对动态分区存储管理方式及其实现过程的理解。
参考文献任满杰等《操作系统原理实用教程》电子工业出版社 2006汤子瀛《计算机操作系统》（修订版）西安电子科技大学出版社 2001张尧学史美林《计算机操作系统教程》实验指导清华大学出版社 2000 罗宇等《操作系统课程设计》机械工业出版社2005审查意见指导教师签字：教研室主任签字：年月日说明：本表由指导教师填写，由教研室主任审核后下达给选题学生，装订在设计（论文）首页1：需求分析（1）用C语言实现采用首次适应算法的动态分区分配过程alloc()和回收过程free()。
其中，空闲分区通过空闲分区链表来管理，在进行内存分配时，系统优先使用空闲区低端的空间。
（2）假设初始状态下，可用的内存空间为640KB，并有下列的请求序列：作业1申请130KB；作业2申请60KB；作业3申请100KB；作业2释放60KB；作业4申请200 KB；作业3释放100 KB；作业1释放130 KB；作业5申请140 KB；作业6申请60 KB；作业7申请50KB；作业6释放60 KB。
计算机操作系统课程设计报告《存储管理——动态分区分配算法的模拟》
《计算机操作系统》课程设计题目：存储管理——动态分区分配算法的模拟专业：软件工程年级：2012级小组成员：指导教师：时间：地点：2012年5 月目录目录 (1)概述 (3)2. 课程设计任务及要求 (3)2.1 设计任务 (3)2.2 设计要求 (3)2.3 课程设计任务安排 (3)3. 算法及数据结构 (4)3.1算法的总体思想（流程） (4)3.2首次适应算法 (4)3.2.1 功能 (4)3.2.2 数据结构（包括变量的定义，要注释！） (4)3.2.3 算法（流程图表示，或伪C表示） (5)3.3循环首次适应算法 (6)3.3.1功能 (6)3.3.2 数据结构 (6)3.3.3算法 (7)3.4最佳适应算法 (8)3.4.1功能 (8)3.4.2 数据结构 (8)3.4.3算法 (8)3.5最坏适应算法 (10)3.5.1功能 (10)3.5.2 数据结构 (10)3.5.3算法 (11)4. 程序设计与实现 (12)4.1 程序流程图 (12)4.2 程序代码（要注释） (12)4.3 实验结果 (21)5. 结论 (23)6. 收获、体会和建议。
(23)A的总结： (23)B的总结： (23)7. 参考文献。
(24)概述动态分区分配是根据进程的实际需要，动态地为之分配内存空间，而在分配时，须按照一定的分配算法，从空闲分区表或空闲分区链中选出一分区分配给该作业。
在本实验中运用了五种分配算法，分别是：1.首次适应算法2.循环首次适应算法3.最坏适应算法4.最佳适应算法5. 快速适应算法2. 课程设计任务及要求2.1设计任务要求设计主界面以灵活选择其中算法，5种算法都要求实现。
2.2设计要求1）首先由系统生成当前的内存状态，要求未分配的分区数量不少于3个，且空间大小随机，然后随机生成一个数，表示等待分配进程的大小。
2）然后显示上述算法由用户选择，结果显示分配后的状态。
3. 算法及数据结构3.1算法的总体思想（流程）设计程序模拟四种动态分区分配算法：首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。
操作系统c语言设计程序模拟内存的动态分区内存管理方法.内存分区使用分区(说明)表
操作系统c语言设计程序模拟内存的动态分区内存管理方法.内存分区使用分区(说明)表1. 引言1.1 概述在计算机科学领域，内存管理是操作系统中至关重要的一个组成部分。
操作系统需要负责对内存资源进行合理的分配和释放，确保程序能够顺利执行，并且不会发生内存泄漏等问题。
本篇文章将介绍一种基于C语言设计程序模拟内存的动态分区内存管理方法。
该方法通过使用分区表来对内存空间进行动态管理。
我们将详细探讨这种方法的实现步骤、技巧以及性能评估和案例分析结果。
1.2 文章结构本文主要分为五个部分：引言、动态分区内存管理方法、C语言设计程序模拟内存的实现步骤与技巧、程序模拟内存动态分区内存管理方法性能评估和案例分析，以及结论与展望。
在引言部分，我们将首先介绍本文的概述，即主题和目标。
然后简要说明文章的结构，以便读者更好地理解全文内容。
1.3 目的本文旨在介绍一种使用C语言设计程序模拟内存的动态分区内存管理方法，并探讨该方法在实际应用中可能遇到的问题和优化建议。
我们希望通过本文的阐述，读者可以对动态分区内存管理方法有更深入的理解，并能够在实际项目中应用相关技术和知识。
通过对程序模拟动态分区内存管理方法进行性能评估和案例分析，我们也旨在为读者提供一个参考，帮助他们更好地理解该方法的优缺点，并从中获得一些有价值的启示。
总之，本文将为读者提供一种全面而深入的了解动态分区内存管理方法的途径，并希望能够激发读者们对内存管理领域研究的兴趣。
2. 动态分区内存管理方法2.1 内存管理概述在操作系统中，内存管理是一个关键的部分。
动态分区内存管理方法是一种常用的内存分配技术，它将可用的内存空间划分为多个不同大小的动态分区，以便满足不同程序对内存空间的需求。
2.2 动态分区内存管理算法原理动态分区内存管理算法主要包括三种：首次适应算法、最佳适应算法和最坏适应算法。
首次适应算法是指从空闲列表中选择第一个能满足所需内存大小的空闲块进行分配。
这种算法简单直观，但可能会产生较大的碎片化问题。
动态分区算法课程设计
动态分区算法课程设计一、课程目标知识目标：1. 让学生掌握动态分区算法的基本概念，理解内存动态分配的原理；2. 学会分析不同动态分区算法的特点，如首次适应算法、最佳适应算法等；3. 了解动态分区算法在操作系统内存管理中的应用。
技能目标：1. 能够运用动态分区算法解决实际问题，提高内存空间的利用率；2. 培养学生编写和调试动态分区算法程序的能力；3. 培养学生通过对比分析，选择合适的动态分区算法解决问题的能力。
情感态度价值观目标：1. 培养学生对操作系统内存管理知识的兴趣，激发学习热情；2. 培养学生的团队合作意识，学会在小组讨论中倾听他人意见；3. 培养学生面对问题积极思考、勇于探索的精神。
课程性质分析：本课程为计算机科学与技术专业课程，旨在帮助学生深入理解操作系统内存管理原理，掌握动态分区算法的应用。
学生特点分析：学生已具备一定的编程基础和操作系统知识，但可能对动态分区算法的了解较少，需要通过本课程进行深入学习。
教学要求：1. 注重理论与实践相结合，提高学生的实际操作能力；2. 激发学生思考，培养学生的创新意识和解决问题的能力；3. 关注学生情感态度的培养，提高学生的学习积极性。
二、教学内容1. 动态分区算法概述：介绍动态分区算法的概念、分类及其在内存管理中的作用；- 相关教材章节：第三章 内存管理，第2节 动态分区算法2. 首次适应算法：讲解首次适应算法的工作原理、实现步骤及优缺点；- 相关教材章节：第三章 内存管理，第2节 动态分区算法，2.1 首次适应算法3. 最佳适应算法：介绍最佳适应算法的工作原理、实现步骤及优缺点；- 相关教材章节：第三章 内存管理，第2节 动态分区算法，2.2 最佳适应算法4. 动态分区算法对比分析：对比不同动态分区算法的性能、适用场景等方面；- 相关教材章节：第三章 内存管理，第2节 动态分区算法，2.3 算法对比分析5. 动态分区算法编程实践：布置编程作业，要求学生编写和调试动态分区算法程序；- 相关教材章节：第三章 内存管理，第2节 动态分区算法，2.4 编程实践6. 动态分区算法在实际应用中的案例分析：分析操作系统内存管理中动态分区算法的应用案例；- 相关教材章节：第三章 内存管理，第2节 动态分区算法，2.5 应用案例分析教学内容安排和进度：第1周：动态分区算法概述第2周：首次适应算法第3周：最佳适应算法第4周：动态分区算法对比分析第5周：动态分区算法编程实践第6周：动态分区算法在实际应用中的案例分析及总结教学内容注重理论与实践相结合，旨在帮助学生系统地掌握动态分区算法的知识，培养其编程能力和解决问题的能力。
动态分区算法课程设计
动态分区算法课程设计一、教学目标本课程旨在让学生了解和掌握动态分区算法的基本概念、原理和实现方法。
通过本课程的学习，学生应达到以下目标：1.知识目标：–了解动态分区算法的定义、特点和应用场景；–掌握动态分区算法的核心思想和基本原理；–熟悉常用的动态分区算法及其优缺点。
2.技能目标：–能够运用动态分区算法解决实际问题；–能够编写程序实现动态分区算法；–能够对动态分区算法的性能进行分析和优化。
3.情感态度价值观目标：–培养学生的逻辑思维能力和创新意识；–增强学生对计算机科学和算法的兴趣和热情；–培养学生团队合作和自主学习的能力。
二、教学内容本课程的教学内容主要包括以下几个部分：1.动态分区算法的基本概念和原理；2.常用的动态分区算法及其实现；3.动态分区算法的应用场景和性能分析；4.动态分区算法的编程实践和案例分析。
具体的教学大纲和进度安排如下：第一周：介绍动态分区算法的基本概念和原理；第二周：学习常用的动态分区算法并编写程序实现；第三周：分析动态分区算法的应用场景和性能；第四周：进行动态分区算法的编程实践和案例分析。
三、教学方法为了激发学生的学习兴趣和主动性，本课程将采用多种教学方法相结合的方式进行教学：1.讲授法：通过讲解和演示，让学生了解动态分区算法的基本概念和原理；2.讨论法：通过小组讨论和思考，让学生深入理解和掌握动态分区算法；3.案例分析法：通过分析和解决实际问题，让学生学会运用动态分区算法；4.实验法：通过编程实践和实验操作，让学生亲手实现和验证动态分区算法。
四、教学资源为了支持教学内容和教学方法的实施，本课程将准备以下教学资源：1.教材：选用权威、实用的教材，提供全面、系统的动态分区算法知识；2.参考书：提供相关的参考书籍，丰富学生的知识视野；3.多媒体资料：制作精美的PPT和教学视频，生动展示动态分区算法的原理和实现；4.实验设备：提供计算机和编程环境，让学生进行编程实践和实验操作。
动态分区分配算法模拟
#include<stdio.h>#include<conio.h>#include<stdlib.h> /* 头文件*/#define VERGE 512 /* 定义内存大小*/typedef struct using{ /* 被占用内存空间大小*/ int num;int from,to;int content;struct using *next;}Use;typedef struct free{ /* 内存空闲区大小*/int from,to;int content;struct free *next;}Free;Use *Umemory;Free *Fmemory;int Unum=0,Fnum=1;void addProcess(int content);void freeProcess(int num);void displayFree();void displayUsing(); /* 所使用子函数*/void main( ){ /* 主函数*/int i;Fnum=1;Fmemory=(Free *)malloc(sizeof(Free));Fmemory->from=0;Fmemory->to=VERGE;Fmemory->content=Fmemory->to-Fmemory->from; Fmemory->next=NULL;Umemory=NULL;while(!kbhit()){ /* 按下键盘任意键结束操作*/i=rand()%2+1;if(Unum-Umemory->num==0||Umemory==NULL)i=2;if(i==1){ /* 释放内存*/i=rand()%(Unum-Umemory->num)+Umemory->num;freeProcess(i);}else{ /* 添加进程*/i=rand()%VERGE;addProcess(i);}displayFree(); /* 显示内存使用情况*/displayUsing(); } }void addProcess(int content){ /* 添加进程*/int i,left=0;Free *p,*minc,*p1,*info;Use *t,*new;p=Fmemory;while(p!=NULL){left+=p->content;p=p->next;}if(content<=0||content>left){printf("add content:%d,left:%d,error\n",content,left);return;}printf("add process:%d\n",content);p=Fmemory;p1=NULL;minc=NULL;while(p!=NULL){if(content<=p->content){minc=p;info=p1;break;}else {p1=info;p=p->next;}}while(p!=NULL){if(p->content<minc->content&&p->content>content){minc=p; info=p1;}else {p1=p;p=p->next;} } /*在剩余空闲区中查找第一个能满足的最小空闲块if(minc!=NULL){if(Umemory==NULL){Umemory=(Use *)malloc(sizeof(Use));Umemory->num=Unum++;Umemory->from=minc->from;Umemory->to=Umemory->from+content;Umemory->content=content;Umemory->next=NULL; }else{ t=Umemory;while(t->next!=NULL)t=t->next;new=(Use *)malloc(sizeof(Use));new->num=Unum++;new->from=minc->from;new->to=new->from+content;new->content=content;new->next=NULL;t->next=new; }minc->from=minc->from+content;minc->content=minc->to-minc->from;if(minc->content==NULL){if(info!=NULL)info->next=minc->next;else Fmemory=minc->next; } } }void freeProcess(int num){ /* 释放内存*/Use *p,*p1;Free *t,*t1,*new;if(num<0||num>=Unum){printf("free: %d error\n",num);return;}p=Umemory;p1=NULL;while(p->num!=num&&p!=NULL){p1=p;p=p->next;}if(p==NULL){printf("free:%d error\n",num);return;}printf("free process:%d,%d,%d,%d\n",num,p->from,p->to,p->content); if(p1!=NULL)p1->next=p->next;else Umemory=Umemory->next;t=Fmemory;t1=NULL;while(t->from<p->to){t1=t;t=t->next;}if(t==Fmemory){if(p->to!=Fmemory->from){t=Fmemory;Fmemory=(Free *)malloc(sizeof(Free));Fmemory->from=p->from;Fmemory->to=p->to;Fmemory->content=p->content;Fmemory->next=t;}else{Fmemory->from=p->from;Fmemory->content=Fmemory->to-Fmemory->from;}}else{if(t1->to==p->from){t1->to=p->to;t1->content=t1->to-t1->from;if(t1->to==t->from){t1->to=t->to;t1->content=t1->to-t1->from;t1->next=t->next;free(t);}}else if(t->from==p->to){t->from=p->from;t->content=t->to-t->from; }else{new=(Free *)malloc(sizeof(Free));new->from=p->from;new->to=p->to;new->content=new->to-new->from;new->next=t;t1->next=new; }} /*合并空闲区*/ free(p);}void displayFree(){ /* 显示空闲区情况*/Free *p;p=Fmemory;if(p!=NULL)printf("The Free Memory:\n");while(p!=NULL){printf("%-3d %-3d %-3d\n",p->from,p->to,p->content);p=p->next; }}void displayUsing(){ /* 显示占用内存情况*/Use *p;p=Umemory;if(p!=NULL)printf("The Using Memory:\n");while(p!=NULL){printf("%-3d%-3d%-3d %-3d\n",p->num,p->from,p->to,p->content); p=p->next; }}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
c++动态分区分配算法模拟(操作系统课程设计)课程设计课程设计名称：操作系统课程设计专业班级：学生姓名：学号：指导教师：课程设计时间：6月13日-——6月17日计算机科学专业课程设计任务书说明：本表由指导教师填写，由教研室主任审核后下达给选题学生，装订在设计（论文）首页1：需求分析（1）用C语言实现采用首次适应算法的动态分区分配过程alloc()和回收过程free()。
其中，空闲分区通过空闲分区链表来管理，在进行内存分配时，系统优先使用空闲区低端的空间。
（2）假设初始状态下，可用的内存空间为640KB，并有下列的请求序列：作业1申请130KB；作业2申请60KB；作业3申请100KB；作业2释放60KB；作业4申请200 KB；作业3释放100 KB；作业1释放130 KB；作业5申请140 KB；作业6申请60 KB；作业7申请50KB；作业6释放60 KB。
采用首次适应算法进行内存块的分配和回收，同时显示内存块分配和回收后空闲内存分区链的情况。
2：概要设计（1）数据结构：作业队列数据结构，用于存储待处理作业；阻塞作业队列数据结构，用于存储阻塞的作业。
已分配内存块的双向链表，记录当前系统已分配的各个内存块；未分配内存块的双向链表，记录系统中剩余的各个内存块；系统内存分配总情况的结点对象，记录系统中阻塞的作业总数，已分配的内存块数，剩余的内存块数。
（2）主函数：对作业队列、阻塞队列、已分配内存块链表、未分配内存块链表、系统总内存分配情况结点对象进行初始化，调用分配函数或回收函数，循环处理11个作业步。
（3）分配函数alloc()：首次适应算法检索未分配的内存块链表，若找到合适的内存块，则加以判断，空闲内存块大小减去作业去请求内存块大小小于系统额定的最小碎片值，把空闲块全部分配，否则进行分割分配，最后显示分配的内存信息。
（4）回收函数free()：首次适应算法检索已分配的内存块链表，找到要释放的内存块后，在已分配链表中删除该结点，并把该结点挂到未分配内存块链表的结尾处，然后进行两次调整，把未分配的内存块链表调整为首地址从小到大的排列顺序，并且物理上相邻的空闲内存块要进行合并，以方便下次进行分配。
调度分配函数，循环处理阻塞作业队列，最后显示回收后的内存情况。
（5）调度图如下：3：运行环境硬件：计算机软件：windowsXP vc++6.04:开发工具和编程语言开发工具：vc++6.0编程语言：C语言5：详细设计（1）：数据结构模块struct job//作业结点{int num;//作业编号int state;//0表示释放，1表示申请int length;//作业要求处理大小};struct yifenpei//已分配内存块结点{int num;//占有内存区域的作业编号int firstadd;//内存区域的首地址int length;//内存区域的大小struct yifenpei*forward;struct yifenpei*next;};struct weifenpei//未分配内存块结点{int firstadd;//空闲区域的首地址int length;//空闲区域的大小struct weifenpei*forward;struct weifenpei*next;};struct total//内存分配状况记录结点{int totalyifen;//已分配的总内存块数int totalweifen;//未分配的总内存块数int totalzuse;//阻塞的作业个数};struct job jobarray[11];//作业处理队列struct yifenpei*headyifen=(struct yifenpei*)malloc(len2);//已分配的内存块所构成的双向链表的头指针struct weifenpei*headweifen=(struct weifenpei*)malloc(len3);//未分配的内存块所构成的双向链表的头指针struct job zuse[11];//阻塞作业队列struct total totalnow;2：主函数模块void main(){jobarray[0].num=1; jobarray[0].state=1; jobarray[0].length=130;/* 初始化请求序列，共11个作业步*/jobarray[1].num=2; jobarray[1].state=1; jobarray[1].length=60;jobarray[2].num=3; jobarray[2].state=1; jobarray[2].length=100;jobarray[3].num=2; jobarray[3].state=0; jobarray[3].length=60;jobarray[4].num=4; jobarray[4].state=1; jobarray[4].length=200;jobarray[5].num=3; jobarray[5].state=0; jobarray[5].length=100;jobarray[6].num=1; jobarray[6].state=0; jobarray[6].length=130;jobarray[7].num=5; jobarray[7].state=1; jobarray[7].length=140;jobarray[8].num=6; jobarray[8].state=1; jobarray[8].length=60;jobarray[9].num=7; jobarray[9].state=1; jobarray[9].length=50;jobarray[10].num=6; jobarray[10].state=0; jobarray[10].length=60;totalnow.totalyifen=0;totalnow.totalweifen=1;totalnow.totalzuse=0;//初始化系统内存分配状况struct weifenpei*weifen=(struct weifenpei*)malloc(len3);weifen->firstadd=1;weifen->forward=headweifen;weifen->length=640;weifen->next=NULL;headweifen->forward=NULL;headweifen->next=weifen;//初始化未分配的内存块双向链表headyifen->next=NULL;headyifen->forward=NULL;//初始化已分配的内存块双向链表for(int m=0;m<11;m++)//初始化阻塞作业队列{zuse[m].num=0;zuse[m].state=0;zuse[m].length=0;}for(int i=0;i<11;i++)//循环处理11个作业步{if(jobarray[i].state==1){alloc(jobarray[i],jobarray[i].num);//调用分配函数}else{free(jobarray[i],jobarray[i].num);//调用释放函数}}printf("全部作业已处理完成!");}3：分配函数模块void alloc(struct job jobnow,int i){int j=1;struct weifenpei*weifennow1=NULL;struct weifenpei*weifennow2=NULL;struct yifenpei*yifennow2=NULL;struct yifenpei*yifennow1=NULL;weifennow1=headweifen;weifennow2=headweifen->next;yifennow1=headyifen;yifennow2=headyifen->next;while(yifennow2!=NULL){yifennow1=yifennow2;yifennow2=yifennow2->next;}yifennow2=(struct yifenpei*)malloc(len2);while(weifennow2!=NULL)//首次适应算法检索合适的内存块{if(weifennow2->length>=jobnow.length){if((weifennow2->length-jobnow.length)<=erding)//内存碎片小于额定值全部分配{weifennow1->next=weifennow2->next;yifennow2->num=i;yifennow2->firstadd=weifennow2->firstadd;yifennow2->length=weifennow2->length;yifennow2->forward=yifennow1;yifennow1->next=yifennow2;yifennow2->next=NULL;totalnow.totalyifen++;totalnow.totalweifen--;}else//否则进行分割分配诶{yifennow2->num=i;yifennow2->firstadd=weifennow2->firstadd;yifennow2->length=jobnow.length;yifennow2->next=NULL;yifennow2->forward=yifennow1;yifennow1->next=yifennow2;weifennow2->length=weifennow2->length-jobnow.length;weifennow2->firstadd=weifennow2->firstadd+jobnow.length;totalnow.totalyifen++;}j=0;break;}weifennow1=weifennow2;weifennow2=weifennow2->next;}if(j)//未找到合适内存块则把作业放入阻塞队列{for(int y=0;y<11;y++){if(zuse[y].num==0){zuse[y].num=jobnow.num;zuse[y].length=jobnow.length;zuse[y].state=jobnow.state;totalnow.totalzuse++;break;}}}weifennow1=headweifen;weifennow2=headweifen->next;yifennow1=headyifen;yifennow2=headyifen->next;printf("当前阻塞作业个数为:%d\n",totalnow.totalzuse);//显示分配后的信息printf("当前已分配%d个存储块:\n",totalnow.totalyifen);while(yifennow2!=NULL){printf("作业号:%d 首地址:%d 大小:%d\n",yifennow2->num,yifennow2->firstadd,yifennow2->length);yifennow1=yifennow2;yifennow2=yifennow2->next;}printf("当前还有%d个空闲存储块:\n",totalnow.totalweifen);while(weifennow2!=NULL){printf("首地址:%d 大小:%d\n",weifennow2->firstadd,weifennow2->length,"\n");weifennow1=weifennow2;weifennow2=weifennow2->next;}printf("\n");}4：回收函数模块void free(struct job jobnow,int i){int j=1;struct weifenpei*weifennow1=NULL;struct weifenpei*weifennow2=NULL;struct yifenpei*yifennow2=NULL;struct yifenpei*yifennow1=NULL;weifennow1=headweifen;weifennow2=headweifen->next;yifennow1=headyifen;yifennow2=headyifen->next;while(weifennow2!=NULL){weifennow1=weifennow2;weifennow2=weifennow2->next;}while(yifennow2!=NULL)//首次适应算法检索已分配链表{if((yifennow2->num==jobnow.num)&&(yifennow2->length==jobnow.length))//找到后直接释放到未分配的内存块的表尾{yifennow1->next=yifennow2->next;yifennow2->next->forward=yifennow1;weifennow2=(struct weifenpei*)malloc(len3);weifennow2->forward=weifennow1;weifennow2->next=NULL;weifennow1->next=weifennow2;weifennow2->firstadd=yifennow2->firstadd;weifennow2->length=yifennow2->length;totalnow.totalyifen--;totalnow.totalweifen++;j=0;break;}yifennow1=yifennow2;yifennow2=yifennow2->next;}if(j==1)//未找到则作业队列有问题{printf("参数错误!");}else//将放到未分配的链表尾部的结点移动到合适的位置{struct weifenpei*weifennow3=headweifen;structweifenpei*weifennow4=headweifen->next;while(weifennow4!=weifennow2){if(weifennow4->next==weifennow2){if((weifennow2->firstadd+weifennow2->length)<weifennow4->firstadd){weifennow4->next=weifennow2->next;weifennow3->next=weifennow2;weifennow2->forward=weifennow3;weifennow2->next=weifennow4;weifennow4->forward=weifennow2;break;}if((weifennow2->firstadd+weifennow2->length)==weifennow4->firstadd){weifennow2->length+=weifennow4->length;weifennow3->next=weifennow2;weifennow2->forward=weifennow3;totalnow.totalweifen--;break;}}else{if((weifennow2->firstadd+weifennow2->length)<weifennow4->firstadd){weifennow2->forward->next=NULL;weifennow3->next=weifennow2;weifennow2->forward=weifennow3;weifennow2->next=weifennow4;weifennow4->forward=weifennow2;break;}if((weifennow2->firstadd+weifennow2->length)==weifennow4->firstadd){weifennow2->forward->next=NULL;weifennow2->length+=weifennow4->length;weifennow3->next=weifennow2;weifennow2->forward=weifennow3;weifennow2->next=weifennow4->next;weifennow4->next->forward=weifennow2;totalnow.totalweifen--;break;}}weifennow3=weifennow4;weifennow4=weifennow4->next;}}weifennow1=headweifen;weifennow2=headweifen->next;while(weifennow2!=NULL)//对未分配的内存块的双向链表进行合并紧凑操作，使得物理上相邻的内存块放到一个记录中{if((weifennow1!=headweifen)&&((weifennow1->firstadd+weifennow1->length)==weifennow2->firstadd)){weifennow2->length+=weifennow1->length;weifennow2->firstadd=weifennow1->firstadd;weifennow2->forward=weifennow1->forward;weifennow1->forward->next=weifennow2;totalnow.totalweifen--;}weifennow1=weifennow2;weifennow2=weifennow2->next;}if(totalnow.totalzuse!=0)//释放内存后再循环处理阻塞队列中的阻塞作业，若仍无合适内存块则继续阻塞{for(int x=0;x<11;x++){if(zuse[x].num!=0){totalnow.totalzuse--;zuse[x].num=0;zuse[x].state=0;zuse[x].length=0;alloc(zuse[x],zuse[x].num);}if(totalnow.totalzuse==0){break;}}}weifennow1=headweifen;weifennow2=headweifen->next;yifennow1=headyifen;yifennow2=headyifen->next;printf("当前阻塞作业个数为:%d\n",totalnow.totalzuse);//显示释放内存以及处理完阻塞作业后的内存分配情况printf("当前已分配%d个存储块:\n",totalnow.totalyifen);while(yifennow2!=NULL){printf("作业号:%d 首地址:%d 大小:%d\n",yifennow2->num,yifennow2->firstadd,yifennow2->length);yifennow1=yifennow2;yifennow2=yifennow2->next;}printf("当前还有%d个空闲存储块:\n",totalnow.totalweifen);while(weifennow2!=NULL){printf("首地址:%d 大小:%d\n",weifennow2->firstadd,weifennow2->length);weifennow1=weifennow2;weifennow2=weifennow2->next;}printf("\n");}6：调试分析（1）设计数据结构时考虑到有两种可供选择，一种是用一个数据结构来描述内存块的分配情况，另外一种是分开描述，我采用了第二种，用两个双向链表来分别描述已分配和未分配的内存块。