㈠ 求C++实现的几个内存分配算法源代码。
http://wenku..com/view/2869ce80ec3a87c24028c46f.html
这里面有C语言实现的上面的两种算法，如果运行不了的话，你可以改改，如果运行成功了的话，你可以根据这个来写出另一个算法的代码。
㈡ 课程设计题目:内存分配模拟系统
国脉的？ 和我所求一样啊
㈢ 谁有这个课程设计：内存分配算法：利用静态链表，模拟实现内存分配
#include <iostream>
#include <string>
using namespace std;
struct ListNode //链表的节点
{
int begin;
int end;
int size;
int num;
bool freeable;
ListNode *next;
};
typedef ListNode * ListPtr;
class Mem
{
public:
Mem();
void getNumStringrequest();
void getNumStringfree();
void getrequest();
void getfreerequest();
// int getNum();
//void Insert();
//void Delete();
void Print();
void freemem();
void getmem();
private:
ListPtr first;
string request;
int requestnum;
int freenum;
string freerequest;
string str;
};
Mem::Mem() //初始化，把first置为空
{
first=new ListNode;
first->next=NULL;
str="";
}
void Mem::getrequest()
{
cout<<"请输入内存申请请求："<<endl;
cin>>request;
str=str+request;
}
void Mem::getfreerequest() //每次的请求都放入str中
{
cout<<"请输入内存释放申请请求："<<endl;
cin>>freerequest;
str=str+freerequest;
}
void Mem::getNumStringrequest()
{
int len=request.length();
string numstring=request.substr(1,len-1);
requestnum=atoi(numstring.c_str());
cout<<"申请内存的大小是："<<requestnum<<endl;
}
void Mem::getNumStringfree() //使用atoi函数将char *（string通过strin.c_str())可以得到char *类型
{
int len=freerequest.length();
string freestring=freerequest.substr(5,len-2);
freenum=atoi(freestring.c_str());
cout<<"释放内存的起始地址是："<<freenum<<endl;
}
void Mem::freemem()
{
ListNode *p=first;
㈣ 内存分配中的快速适应算法
如果空间分区划分的越细，则小空间就越多。此时，若是大部分进程长度都是大于大多数空间分区，则这些小于改进程长度的空间分区都不可被分配，从而造成更多了内存空间浪费。所以空间分区划分不应该太细，应保证在一定的范围，这样就可以容纳更广范围的进程。
㈤ 什么是最优适应分配算法
分区分配算法(Partitioning Placement Algorithm) ，共有3种。分别为最佳适应算法、首次适应算法、循环首次适应算法。
1、最佳适应算法（Best Fit）：
它从全部空闲区中找出能满足作业要求的、且大小最小的空闲分区，这种方法能使碎片尽量小。为适应此算法，空闲分区表（空闲区链）中的空闲分区要按大小从小到大进行排序，自表头开始查找到第一个满足要求的自由分区分配。该算法保留大的空闲区，但造成许多小的空闲区。
2、首次适应算法（First Fit）：
从空闲分区表的第一个表目起查找该表，把最先能够满足要求的空闲区分配给作业，这种方法目的在于减少查找时间。为适应这种算法，空闲分区表（空闲区链）中的空闲分区要按地址由低到高进行排序。该算法优先使用低址部分空闲区，在低址空间造成许多小的空闲区，在高地址空间保留大的空闲区。
3、循环首次适应算法(Next Fit)：
该算法是首次适应算法的变种。在分配内存空间时，不再每次从表头（链首）开始查找，而是从上次找到空闲区的下一个空闲开始查找，直到找到第一个能满足要求的的空闲区为止，并从中划出一块与请求大小相等的内存空间分配给作业。该算法能使内存中的空闲区分布得较均匀。
㈥ 采用c语言实现首次适应算法完成主存空间的分配和回收 急
有没有具体的要求，比方说数据结构方面，我这有一个，你可以参考参考
#include"stdio.h"
#include"stdlib.h"
#define
n
10
/*假定系统允许的最大作业为n，假定模拟实验中n值为10*/
#define
m
10
/*假定系统允许的空闲区表最大为m，假定模拟实验中m值为10*/
#define
minisize
100
struct{
float
address;
/*已分分区起始地址*/
float
length;
/*已分分区长度，单位为字节*/
int
flag;
/*已分配区表登记栏标志，用"0"表示空栏目*/
}used_table[n];
/*已分配区表*/
struct{
float
address;
/*空闲区起始地址*/
float
length;
/*空闲区长度，单位为字节*/
int
flag;
/*空闲区表登记栏标志，用"0"表示空栏目，用"1"表示未分配*/
}free_table[m];
/*空闲区表*/
void
main(
)
{
int
i,a;
void
allocate(char
str,float
leg);//分配主存空间函数
void
reclaim(char
str);//回收主存函数
float
xk;
char
J;/*空闲分区表初始化：*/
free_table[0].address=10240;
free_table[0].length=102400;
free_table[0].flag=1;
for(i=1;i<m;i++)
free_table[i].flag=0;/*已分配表初始化：*/
for(i=0;i<n;i++)
used_table[i].flag=0;
while(1)
{
printf("\n选择功能项（0-退出,1-分配主存,2-回收主存,3-显示主存）\n");
printf("选择功项(0~3)
:");
scanf("%d",&a);
switch(a)
{
case
0:
exit(0);
/*a=0程序结束*/
case
1:
/*a=1分配主存空间*/printf("输入作业名J和作业所需长度xk:
");
scanf("%*c%c%f",&J,&xk);
allocate(J,xk);/*分配主存空间*/
break;
case
2:
/*a=2回收主存空间*/printf("输入要回收分区的作业名");
scanf("%*c%c",&J);reclaim(J);/*回收主存空间*/
break;
case
3:
/*a=3显示主存情况*//*输出空闲区表和已分配表的内容*/
printf("输出空闲区表：\n起始地址
分区长度
标志\n");
for(i=0;i<m;i++)
printf("%6.0f%9.0f%6d\n",free_table[i].address,free_table[i].length,
free_table[i].flag);
printf("
按任意键,输出已分配区表\n");
getchar();
printf("
输出已分配区表：\n起始地址
分区长度
标志\n");
for(i=0;i<n;i++)
if(used_table[i].flag!=0)
printf("%6.0f%9.0f%6c\n",used_table[i].address,used_table[i].length,
used_table[i].flag);
else
printf("%6.0f%9.0f%6d\n",used_table[i].address,used_table[i].length,
used_table[i].flag);
break;
default:printf("没有该选项\n");
}/*case*/
}/*while*/
}/*主函数结束*/
int
uflag;//分配表标志
int
fflag;//空闲表标志
float
uend_address;
float
fend_address;
void
allocate(char
str,float
leg)
{
uflag=0;fflag=0;
int
k,i;float
ressize;
for(i=0;i<m;i++)
{
if(free_table[i].flag==1
&&
free_table[i].length>=leg)
{
fflag=1;break;
}
}
if(fflag==0)
printf("没有满足条件的空闲区\n");
else
{
ressize=free_table[i].length-leg;
for(k=0;k<n;k++)
{
if(used_table[k].flag==0)
{
if(ressize<minisize)//剩余块过小
{
used_table[k].length=free_table[i].length;
used_table[k].address=free_table[i].address;
used_table[k].flag=str;
free_table[i].length=0;
free_table[i].flag=0;
break;
}
else
{
used_table[k].address=free_table[i].address+ressize;
used_table[k].flag=str;
used_table[k].length=leg;
free_table[i].length=ressize;
break;
}
}
}//for结束
}
}
void
reclaim(char
str)
{
uflag=0;fflag=0;
int
k,i;
for(k=0;k<n;k++)
{
if(used_table[k].flag==str)
{
uflag=1;break;
}
}
if(uflag==0)
printf("\n找不到该作业!\n");
else
{
for(i=0;i<m;i++)
{
uend_address=used_table[k].address+used_table[k].length;
fend_address=free_table[i].address+free_table[i].length;
if(used_table[k].address==fend_address)//上邻
{
fflag=1;
free_table[i].length=free_table[i].length+used_table[k].length;
free_table[i].flag=1;
used_table[k].flag=0;
used_table[k].length=0;
used_table[k].address=0;
printf("\n已回收!\n");
break;
}
else
{
if(free_table[i].address==uend_address)//下邻
{
fflag=1;
free_table[i].address=used_table[k].address;
free_table[i].length=free_table[i].length+used_table[k].length;
free_table[i].flag=1;
used_table[k].flag=0;
used_table[k].length=0;
used_table[k].address=0;
printf("\n已回收!\n");
break;
}
}
}//for结束
if(fflag==0)
{
i=0;
for(i=0;i<m;i++)
{
if(free_table[i].flag==0)
{
free_table[i].address=used_table[k].address;
free_table[i].length=used_table[k].length;
free_table[i].flag=1;
used_table[k].length=0;
used_table[k].flag=0;
used_table[k].address=0;
break;
}
}
printf("\n已回收!\n");
}
}
}
㈦ 谁能帮给我这个课题的源代码，速度帮我谢谢拉
20分不够喂。。。。。这个要敲很久代码
㈧ [编程知识]如何分配内存 内存碎片处理技术
内存碎片是一个很棘手的问题。如何分配内存决定着内存碎片是否会、何时会、如何会成为一个问题。 即使在系统中事实上仍然有许多空闲内存时，内存碎片还会最终导致出现内存用完的情况。一个不断产生内存碎片的系统，不管产生的内存碎片多么小，只要时间足够长，就会将内存用完。这种情况在许多嵌入式系统中，特别是在高可用性系统中是不可接受的。有些软件环境，如 OSE 实时操作系统已经备有避免内存碎片的良好工具，但个别程序员做出的选择仍然会对最终结果形成影响。 “碎片的内存”描述一个系统中所有不可用的空闲内存。这些资源之所以仍然未被使用，是因为负责分配内存的分配器使这些内存无法使用。这一问题通常都会发生，原因在于空闲内存以小而不连续方式出现在不同的位置。由于分配方法决定内存碎片是否是一个问题，因此内存分配器在保证空闲资源可用性方面扮演着重要的角色。 编译时间与运行时间 在许多情况下都会出现内存分配问题。程序员可以通过编译程序和链接程序，为结构、并集、数组和标量（用作局部变量、静态变量或全局变量）方面的数据分配内存，程序员还可以在运行时间使用诸如 malloc()调用命令动态地分配内存。当用编译程序和链接程序完成内存分配功能时，就不会出现内存碎片，因为编译程序了解数据寿命。掌握可供使用的数据寿命，好处在于可以使数据以后进先出的方式叠加起来。这样就可以使内存分配程序工作效率更高，而不会出现内存碎片。一般来说，运行时间内的内存分配是不可叠加的。内存分配在时间上是独立的，从而使得碎片问题难以解决。 图1，内存碎片的几种形式。 内存分配程序浪费内存的基本方式有三种：即额外开销、内部碎片以及外部碎片（图 1）。内存分配程序需要存储一些描述其分配状态的数据。这些存储的信息包括任何一个空闲内存块的位置、大小和所有权，以及其它内部状态详情。一般来说，一个运行时间分配程序存放这些额外信息最好的地方是它管理的内存。内存分配程序需要遵循一些基本的内存分配规则。例如，所有的内存分配必须起始于可被 4、8 或 16 整除（视处理器体系结构而定）的地址。内存分配程序把仅仅预定大小的内存块分配给客户，可能还有其它原因。当某个客户请求一个 43 字节的内存块时，它可能会获得 44字节、48字节 甚至更多的字节。由所需大小四舍五入而产生的多余空间就叫内部碎片。 外部碎片的产生是当已分配内存块之间出现未被使用的差额时，就会产生外部碎片。例如，一个应用程序分配三个连续的内存块，然后使中间的一个内存块空闲。内存分配程序可以重新使用中间内存块供将来进行分配，但不太可能分配的块正好与全部空闲内存一样大。倘若在运行期间，内存分配程序不改变其实现法与四舍五入策略，则额外开销和内部碎片在整个系统寿命期间保持不变。虽然额外开销和内部碎片会浪费内存，因此是不可取的，但外部碎片才是嵌入系统开发人员真正的敌人，造成系统失效的正是分配问题。 定义内存碎片的方法有几种，其中最常用的是： 这一方法适用于外部碎片，但可以修改这一公式使之包括内部碎片，办法是把内部碎片加入到分母中。内存碎片是一个介于 0 和 1 之间的分数。一个碎片为 1(100%)的系统就是把内存全用完了。如果所有空闲内存都在一个内存块（最大内存块）中，碎片为 0%。当所有空闲内存的四分之一在最大内存块中时，碎片为 75%。例子如下：一个系统有 5M 字节的空闲内存，当它可用来分配的最大内存块为 50 k 字节时，其内存碎片为99%。这个 99%内存碎片实例来自开发嵌入式软实时系统期间出现的一种真实情况。当这种碎片程度发生一秒后，系统就崩溃了。该系统在碎片率达到 99% 之前，已经进行了约两周的连续现场测试。这种情况是如何发生的？为什么会发现得如此晚？当然，系统都经过测试，但测试很少超过两个小时。交付前的最后压力测试持续了一个周末。在这样短的测试周期内未必会产生内存碎片的后果，所以就发生了内存碎片需要多长时间才会达到临界值，这一问题很难回答。对某些应用来说，在某些情况下，系统会在用完内存前达到一种稳定状态。而对于另一些应用来说，系统则不会及时达到稳定状态（图 2）。只要消除不确定性因素和风险因素，不产生碎片的内存分配程序（图 3）就能快速达到一种稳定状态，从而有助于开发人员夜晚安稳睡觉。在开发数月甚至数年不再重新启动的长期运行系统时，快速收敛到稳定状态是一个重要因素。在比系统连续运行周期短的时间内，对系统进行适当的测试，这是必不可少的。 图2，这一案例研究把最先适合内存分配程序用于一个嵌入系统项目。系统在现场测试中连续运行了两周，然后碎片率达到 99%。图3，一个不产生碎片的内存分配程序一旦试验应用程序的全部，它就能达到稳定状态。 很难确定哪种内存分配算法更胜一筹，因为每种算法在不同的应用中各有所长（表 1）。最先适合内存分配算法是最常用的一种。它使用了四个指针：MSTART 指向被管理内存的始端；MEND 指向被管理内存的末尾；MBREAK 指向 MSTART 和 MEND 之间已用内存的末端； PFREE 则指向第一个空闲内存块（如果有的话）。 在系统开始运行时，PFREE 为 NULL，MBREAK 指向 MSTART。当一个分配请求来到时，分配程序首先检查 PFREE有无空闲内存块。由于 PFREE 为 NULL，一个具有所请求存储量加上管理标题的内存块就脱离 MBREAK ，然后MBREAK就更新。这一过程反复进行，直至系统使一个内存块空闲，管理标题包含有该存储块的存储量为止。此时，PFREE 通过头上的链接表插入项被更新为指向该内存块，而块本身则用一个指向旧 PFREE 内容的指针进行更新，以建立一个链接表。下一次出现分配请求时，系统就会搜索空闲内存块链接表，寻找适合请求存储量的第一个空闲内存块。一旦找到合适的内存块，它将此内存块分成两部分，一部分返还给系统，另一部分则送回给自由表。 最先适合内存分配算法实现起来简单，而且开始时很好用。但是，经过一段时间后，会出现如下的情况：当系统将内存交给自由表时，它会从自由表的开头部分去掉大内存块，插入剩余的小内存块。最先适合算法实际上成了一个排序算法，即把所有小内存碎片放在自由表的开头部分。因此，自由表会变得很长，有几百甚至几千个元素。因此，内存分配变得时间很长又无法预测，大内存块分配所花时间要比小内存块分配来得长。另外，内存块的无限制拆分使内存碎片程度很高。有些实现方法在使内存空闲时会将邻近的空闲内存块连接起来。这种方法多少有些作用，而最先适合算法与时间共处算法(time co-location)和空间共处算法(spatial co-location)不同，它在使内存块空闲时，无法提高相邻内存块同时空闲的概率。 最佳适合与最差适合分配程序 最佳适合算法在功能上与最先适合算法类似，不同之处是，系统在分配一个内存块时，要搜索整个自由表，寻找最接近请求存储量的内存块。这种搜索所花的时间要比最先适合算法长得多，但不存在分配大小内存块所需时间的差异。最佳适合算法产生的内存碎片要比最先适合算法多，因为将小而不能使用的碎片放在自由表开头部分的排序趋势更为强烈。由于这一消极因素，最佳适合算法几乎从来没有人采用过。 最差适合算法也很少采用。最差适合算法的功能与最佳适合算法相同，不同之处是，当分配一个内存块时，系统在整个自由表中搜索与请求存储量不匹配的内存快。这种方法比最佳适合算法速度快，因为它产生微小而又不能使用的内存碎片的倾向较弱。始终选择最大空闲内存块，再将其分为小内存块，这样就能提高剩余部分大得足以供系统使用的概率。 伙伴(buddy)分配程序与本文描述的其它分配程序不同，它不能根据需要从被管理内存的开头部分创建新内存。它有明确的共性，就是各个内存块可分可合，但不是任意的分与合。每个块都有个朋友，或叫“伙伴”，既可与之分开，又可与之结合。伙伴分配程序把内存块存放在比链接表更先进的数据结构中。这些结构常常是桶型、树型和堆型的组合或变种。一般来说，伙伴分配程序的工作方式是难以描述的，因为这种技术随所选数据结构的不同而各异。由于有各种各样的具有已知特性的数据结构可供使用，所以伙伴分配程序得到广泛应用。有些伙伴分配程序甚至用在源码中。伙伴分配程序编写起来常常很复杂，其性能可能各不相同。伙伴分配程序通常在某种程度上限制内存碎片。 固定存储量分配程序有点像最先空闲算法。通常有一个以上的自由表，而且更重要的是，同一自由表中的所有内存块的存储量都相同。至少有四个指针：MSTART 指向被管理内存的起点，MEND 指向被管理内存的末端，MBREAK 指向 MSTART 与 MEND 之间已用内存的末端，而 PFREE[n] 则是指向任何空闲内存块的一排指针。在开始时，PFREE[*] 为 NULL，MBREAK 指针为 MSTART。当一个分配请求到来时，系统将请求的存储量增加到可用存储量之一。然后，系统检查 PFREE[ 增大后的存储量 ] 空闲内存块。因为 PFREE[ 增大后的存储量 ] 为 NULL，一个具有该存储量加上一个管理标题的内存块就脱离 MBREAK，MBREAK 被更新。 这些步骤反复进行，直至系统使一个内存块空闲为止，此时管理标题包含有该内存块的存储量。当有一内存块空闲时，PFREE[ 相应存储量 ] 通过标题的链接表插入项更新为指向该内存块，而该内存块本身则用一个指向 PFREE[ 相应存储量 ] 以前内容的指针来更新，以建立一个链接表。下一次分配请求到来时，系统将 PFREE[ 增大的请求存储量 ] 链接表的第一个内存块送给系统。没有理由搜索链接表，因为所有链接的内存块的存储量都是相同的。 固定存储量分配程序很容易实现，而且便于计算内存碎片，至少在块存储量的数量较少时是这样。但这种分配程序的局限性在于要有一个它可以分配的最大存储量。固定存储量分配程序速度快，并可在任何状况下保持速度。这些分配程序可能会产生大量的内部内存碎片，但对某些系统而言，它们的优点会超过缺点。 减少内存碎片 内存碎片是因为在分配一个内存块后，使之空闲，但不将空闲内存归还给最大内存块而产生的。最后这一步很关键。如果内存分配程序是有效的，就不能阻止系统分配内存块并使之空闲。即使一个内存分配程序不能保证返回的内存能与最大内存块相连接（这种方法可以彻底避免内存碎片问题），但你可以设法控制并限制内存碎片。所有这些作法涉及到内存块的分割。每当系统减少被分割内存块的数量，确保被分割内存块尽可能大时，你就会有所改进。 这样做的目的是尽可能多次反复使用内存块，而不要每次都对内存块进行分割，以正好符合请求的存储量。分割内存块会产生大量的小内存碎片，犹如一堆散沙。以后很难把这些散沙与其余内存结合起来。比较好的办法是让每个内存块中都留有一些未用的字节。留有多少字节应看系统要在多大程度上避免内存碎片。对小型系统来说，增加几个字节的内部碎片是朝正确方向迈出的一步。当系统请求1字节内存时，你分配的存储量取决于系统的工作状态。 如果系统分配的内存存储量的主要部分是 1 ～ 16 字节，则为小内存也分配 16 字节是明智的。只要限制可以分配的最大内存块，你就能够获得较大的节约效果。但是，这种方法的缺点是，系统会不断地尝试分配大于极限的内存块，这使系统可能会停止工作。减少最大和最小内存块存储量之间内存存储量的数量也是有用的。采用按对数增大的内存块存储量可以避免大量的碎片。例如，每个存储量可能都比前一个存储量大 20%。在嵌入式系统中采用“一种存储量符合所有需要”对于嵌入式系统中的内存分配程序来说可能是不切实际的。这种方法从内部碎片来看是代价极高的，但系统可以彻底避免外部碎片，达到支持的最大存储量。 将相邻空闲内存块连接起来是一种可以显着减少内存碎片的技术。如果没有这一方法，某些分配算法（如最先适合算法）将根本无法工作。然而，效果是有限的，将邻近内存块连接起来只能缓解由于分配算法引起的问题，而无法解决根本问题。而且，当内存块存储量有限时，相邻内存块连接可能很难实现。 有些内存分配器很先进，可以在运行时收集有关某个系统的分配习惯的统计数据，然后，按存储量将所有的内存分配进行分类，例如分为小、中和大三类。系统将每次分配指向被管理内存的一个区域，因为该区域包括这样的内存块存储量。较小存储量是根据较大存储量分配的。这种方案是最先适合算法和一组有限的固定存储量算法的一种有趣的混合，但不是实时的。 有效地利用暂时的局限性通常是很困难的，但值得一提的是，在内存中暂时扩展共处一地的分配程序更容易产生内存碎片。尽管其它技术可以减轻这一问题，但限制不同存储量内存块的数目仍是减少内存碎片的主要方法。 现代软件环境业已实现各种避免内存碎片的工具。例如，专为分布式高可用性容错系统开发的 OSE 实时操作系统可提供三种运行时内存分配程序：内核 alloc()，它根据系统或内存块池来分配；堆 malloc()，根据程序堆来分配； OSE 内存管理程序 alloc_region，它根据内存管理程序内存来分配。 从 许多方面来看，Alloc就是终极内存分配程序。它产生的内存碎片很少，速度很快，并有判定功能。你可以调整甚至去掉内存碎片。只是在分配一个存储量后，使之空闲，但不再分配时，才会产生外部碎片。内部碎片会不断产生，但对某个给定的系统和八种存储量来说是恒定不变的。 Alloc 是一种有八个自由表的固定存储量内存分配程序的实现方法。系统程序员可以对每一种存储量进行配置，并可决定采用更少的存储量来进一步减少碎片。除开始时以外，分配内存块和使内存块空闲都是恒定时间操作。首先，系统必须对请求的存储量四舍五入到下一个可用存储量。就八种存储量而言，这一目标可用三个 如果 语句来实现。其次，系统总是在八个自由表的表头插入或删除内存块。开始时，分配未使用的内存要多花几个周期的时间，但速度仍然极快，而且所花时间恒定不变。 堆malloc() 的内存开销（8 ～ 16 字节/分配）比 alloc小，所以你可以停用内存的专用权。malloc() 分配程序平均来讲是相当快的。它的内部碎片比alloc()少，但外部碎片则比alloc()多。它有一个最大分配存储量，但对大多数系统来说，这一极限值足够大。可选的共享所有权与低开销使 malloc() 适用于有许多小型对象和共享对象的 C++ 应用程序。堆是一种具有内部堆数据结构的伙伴系统的实现方法。在 OSE 中，有 28 个不同的存储量可供使用，每种存储量都是前两种存储量之和，于是形成一个斐波那契（Fibonacci）序列。实际内存块存储量为序列数乘以 16 字节，其中包括分配程序开销或者 8 字节/分配（在文件和行信息启用的情况下为 16 字节）。 当你很少需要大块内存时，则OSE内存管理程序最适用。典型的系统要把存储空间分配给整个系统、堆或库。在有 MMU 的系统中，有些实现方法使用 MMU 的转换功能来显着降低甚至消除内存碎片。在其他情况下，OSE 内存管理程序会产生非常多的碎片。它没有最大分配存储量，而且是一种最先适合内存分配程序的实现方法。内存分配被四舍五入到页面的偶数——典型值是 4 k 字节。（T111）
㈨ 如何用C语言实现动态分区分配算法的模拟
#define_CRT_SECURE_NO_WARNINGS1
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#defineN10000
intn1;//空闲分区的个数
intn2;//作业区的个数
structkongxian
{
intstart;//起址
intend;//结束
intlength;//长度
}kongxian[N];
structzuoye
{
intstart;//起址
intend;//结束
intlength;//长度
}zuoye[N];
intcmp1(constvoid*a,constvoid*b)
{
return(*(structkongxian*)a).start-(*(structkongxian*)b).start;
}
intcmp2(constvoid*a,constvoid*b)
{
return(*(structzuoye*)a).start-(*(structzuoye*)b).start;
}
voidinit()
{
n1=1;//初始时只有一个空闲区
n2=0;//初始没有作业
kongxian[0].start=0;
kongxian[0].end=511;
kongxian[0].length=512;
}
voidprint1()//打印空闲分区
{
inti;
for(i=0;i<n1;i++)
printf("空闲分区ID:%d起止:%d结束:%d长度:%d ",i,kongxian[i].start,kongxian[i].end,kongxian[i].length);
}
voidprint2()//打印作业分区
{
inti;
for(i=0;i<n2;i++)
printf("作业分区ID：%d起止:%d结束:%d长度:%d ",i,zuoye[i].start,zuoye[i].end,zuoye[i].length);
}
intmain()
{
inti,j,t,len,flag,id;
intfront,middle,behind;
intt1,t2;
init();
print1();
printf("输入1装入新作业，输入0回收作业，输入-1结束 ");
while(scanf("%d",&t)!=EOF)
{
if(t==1)//装入新作业
{
printf("请输入作业的占用空间的长度");
scanf("%d",&len);
flag=0;
for(i=0;i<n1;i++)
{
if(kongxian[i].length>=len)//首次适应算法
{
flag=1;
break;
}
}
if(!flag)
{
printf("内存分配失败 ");
}
else
{
//将该作业加入作业区里
zuoye[n2].start=kongxian[i].start;
zuoye[n2].end=zuoye[n2].start+len;
zuoye[n2].length=len;
n2++;//作业数加1
if(kongxian[i].length==len)//该分区全部用于分配，删除该空闲分区
{
for(j=i;j<n1-1;j++)
{
kongxian[j].start=kongxian[j+1].start;
kongxian[j].end=kongxian[j+1].end;
kongxian[j].length=kongxian[j+1].length;
}
n1--;
}
else//该空闲分区部分用于分配，剩余的留在空闲分区中
{
kongxian[i].start+=len;
kongxian[i].length-=len;
}
}
}
elseif(t==0)
{
printf("输入要回收的作业ID");
scanf("%d",&id);
front=middle=behind=0;
for(i=0;i<n1;i++)
{
if(kongxian[i].start>zuoye[id].end)
break;
if(kongxian[i].end==zuoye[id].start)//待回收的作业上面有空闲分区
{
front=1;
t1=i;
}
if(kongxian[i].start==zuoye[id].end)//待回收的作业下面有空闲分区
{
behind=1;
t2=i;
}
}
if(!front&&!behind)//待回收的作业上下均没有空闲分区
{
kongxian[n1].start=zuoye[id].start;
kongxian[n1].end=zuoye[id].end;
kongxian[n1].length=zuoye[id].length;
n1++;//空闲分区增加一个
qsort(kongxian,n1,sizeof(structkongxian),cmp1);//插入空闲分区后排序
for(j=id;j<n2-1;j++)//在作业分区中删除该作业
{
zuoye[j].start=zuoye[j+1].start;
zuoye[j].end=zuoye[j+1].end;
zuoye[j].length=zuoye[j+1].length;
}
n2--;
}
if(front&&behind)//待回收的作业上下均有空闲分区
middle=1;
if(front&&!middle)//合并待回收的作业和上面的空闲分区
{
kongxian[t1].end+=zuoye[id].length;
kongxian[t1].length+=zuoye[id].length;
for(j=id;j<n2-1;j++)//在作业分区中删除该作业
{
zuoye[j].start=zuoye[j+1].start;
zuoye[j].end=zuoye[j+1].end;
zuoye[j].length=zuoye[j+1].length;
}
n2--;
}
if(middle)//合并待回收的作业和上下的空闲分区
{
kongxian[t1].end=kongxian[t2].end;
kongxian[t1].length+=(zuoye[id].length+kongxian[t2].length);
//删除空闲分区t2
for(j=t2;j<n1-1;j++)
{
kongxian[j].start=kongxian[j+1].start;
kongxian[j].end=kongxian[j+1].end;
kongxian[j].length=kongxian[j+1].length;
}
n1--;
for(j=id;j<n2-1;j++)//在作业分区中删除该作业
{
zuoye[j].start=zuoye[j+1].start;
zuoye[j].end=zuoye[j+1].end;
zuoye[j].length=zuoye[j+1].length;
}
n2--;
}
if(behind&&!middle)//合并待回收的作业和下面的分区
{
kongxian[t2].start-=zuoye[id].length;
kongxian[t2].length+=zuoye[id].length;
for(j=id;j<n2-1;j++)//在作业分区中删除该作业
{
zuoye[j].start=zuoye[j+1].start;
zuoye[j].end=zuoye[j+1].end;
zuoye[j].length=zuoye[j+1].length;
}
n2--;
}
}
else
{
printf("操作结束 ");
break;
}
print1();
print2();
}
return0;
}