操作系统-系统内存分配的适应算法（1）

一：最佳适应算法和首次适应算法

#include<iostream>

#include<stdlib.h>
using namespace std;


#define Free 0 //空闲状态
#define Busy 1 //已用状态
#define OK 1    //完成
#define ERROR 0 //出错
#define MAX_length 640 //最大内存空间为640KB
typedef int Status;


typedef struct freearea//定义一个空闲区说明表结构
{
int ID;   //分区号
long size;   //分区大小
long address; //分区地址
int state;   //状态
}ElemType;


//----------  线性表的双向链表存储结构  ------------
typedef struct DuLNode //double linked list
{
ElemType data;
struct DuLNode *prior; //前趋指针
struct DuLNode *next;  //后继指针
}DuLNode, *DuLinkList;


DuLinkList block_first; //头结点
DuLinkList block_last;  //尾结点


Status alloc(int);//内存分配
Status free(int); //内存回收
Status First_fit(int, int);//首次适应算法
Status Best_fit(int, int); //最佳适应算法
void show();//查看分配
Status Initblock();//开创空间表


Status Initblock()//开创带头结点的内存空间链表
{
block_first = (DuLinkList)malloc(sizeof(DuLNode));
block_last = (DuLinkList)malloc(sizeof(DuLNode));
block_first->prior = NULL;
block_first->next = block_last;
block_first->data.state = 3;
block_first->data.size = 0;
block_last->prior = block_first;
block_last->next = NULL;
block_last->data.address = 0;
block_last->data.size = MAX_length;
block_last->data.ID = 0;
block_last->data.state = Free;
return OK;
}


//----------------------- 分 配 主 存 -------------------------
Status alloc(int ch)
{
int ID, request;
cout << "请输入作业(分区号（整数）)：";
cin >> ID;
cout << "请输入需要分配的主存大小(单位:KB)：";
cin >> request;
if (request<0 || request == 0)
{
cout << "分配大小不合适，请重试！" << endl;
return ERROR;
}


if (ch == 2) //选择最佳适应算法
{
if (Best_fit(ID, request) == OK) cout << "分配成功！" << endl;
else cout << "内存不足，分配失败！" << endl;
return OK;
}
else //默认首次适应算法
{
if (First_fit(ID, request) == OK) cout << "分配成功！" << endl;
else cout << "内存不足，分配失败！" << endl;
return OK;
}
}
//------------------ 首次适应算法 -----------------------
Status First_fit(int ID, int request)//传入作业名及申请量
{
DuLNode *p = block_first->next;
//请在此处添加为作业申请新空间且初始化的代码
//请在此处完成首次适应算法的代码，分两种情况：有大小恰好合适的空闲块和有空闲块能满足需求且有剩余。
//注意函数返回值。
DuLinkList block = (DuLinkList)malloc(sizeof(DuLNode));
memset(block, 0, sizeof(DuLNode));
block->data.ID = ID;
block->data.size = request;
block->data.state = Busy;
while (p)
{
if (p->data.state == Free && p->data.size >= request)
{
if ((p->data.size - request) > 1)
{

block->data.address = p->data.address;
p->data.address = p->data.address + request;
p->data.size = p->data.size - request;


p->prior->next = block;
block->next = p;
block->prior = p->prior;
p->prior = block;
return OK;
}
else
{
p->data.ID = ID;
p->data.state = Busy;
free(block);
return OK;
}
}
p = p->next;
}
free(block);
return ERROR;
}
//--------------------  最佳适应算法  ------------------------
Status Best_fit(int ID, int request)
{
//请在此处添加为作业申请新空间且初始化的代码
DuLinkList block = (DuLinkList)malloc(sizeof(DuLNode));
memset(block, 0, sizeof(DuLNode));
block->data.ID = ID;
block->data.size = request;
block->data.state = Busy;
DuLNode *p = block_first->next;
DuLNode *q = NULL; //记录最佳插入位置
int i = 0;
int num = 0;
DuLNode *q1 = NULL;

while (p)
{

if (p->data.state == Free && p->data.size >= request)
{
if (num == 0)
{
q = p;
i = q->data.size - request;


}
else if (p->data.size - request < i)
{
q = p;
i = q->data.size - request;
}
num++;

}


p = p->next;
}


//请在此处完成最佳适应算法的代码，重点：要查找到最小剩余空间的分区，即最佳插入位置


if (q == NULL) return ERROR;//没有找到空闲块
else
{
//请插入找到了最佳位置并实现内存分配的代码！
if ((q->data.size - request) > 1)
{


block->data.address = q->data.address;
q->data.address = q->data.address + request;
q->data.size = q->data.size - request;


block->next = q;
block->prior = q->prior;
q->prior->next = block;
q->prior = block;
return OK;
}
else
{
q->data.ID = ID;
q->data.state = Busy;
free(block);
return OK;
}
}
}


//-----------------------   主 存 回 收   --------------------
Status free(int ID)
{
DuLNode *p = block_first->next;
DuLNode *p1 = NULL;
while (p)
{
if (p->data.ID == ID)
{
p->data.state = Free;
p->data.ID = Free;
cout << "内存块找到，准备回收！" << endl;
if (p->next == NULL){
if ((p->prior->data.state == Free) && (p->prior->data.address + p->prior->data.size == p->data.address))
{
p->prior->data.size += p->data.size;
p->prior->next = NULL;
free(p);
}
cout << "内存块为最后一块！" << endl;
break;
}
//请在此处添加其他情况的回收的代码，主要包括要回收的分区与前面的空闲块相连或与后面的空闲块相连，或者与前后空闲块相连等。
   if ((p->next->next == NULL) && (p->next->data.state == Free) && (p->data.address + p->data.size == p->next->data.address))
{
p->data.size += p->next->data.size;
free(p->next);
p->next = NULL;
if ((p->prior->data.state == Free) && (p->prior->data.address + p->prior->data.size == p->data.address))
{
p->prior->data.size += p->data.size;
p->prior->next = NULL;
free(p);  


}
break;


}
else if ((p->prior->data.state == Free)&&(p->prior->data.address+p->prior->data.size == p->data.address))
{

if ( p->next->data.state == Free && (p->data.address + p->data.size == p->next->data.address))
{
p1 = p->next;
p->data.size += p->next->data.size;
p->next->next->prior = p;


p->next = p->next->next;
free(p1);

}
p->prior->data.size += p->data.size;
p->prior->next = p->next;
p->next->prior = p->prior;
free(p);
break;
}
else if ((p->next->data.state == Free) && (p->data.address + p->data.size == p->next->data.address))
{
p1 = p->next;
p->data.size += p->next->data.size;
p->next = p->next->next;
p->next->prior = p;
free(p1);
break;
}
break;
}
p = p->next;
}
cout << "回收成功！" << endl;
return OK;
}


//---------------  显示主存分配情况 ------------------
void show()
{
cout << "+++++++++++++++++++++++++++++++++++++++\n";
cout << "+++        主 存 分 配 情 况        +++\n";
cout << "+++++++++++++++++++++++++++++++++++++++\n";
DuLNode *p = block_first->next;
while (p)
{
cout << "分 区 号：";
if (p->data.ID == Free) cout << "Free" << endl;
else cout << p->data.ID << endl;
cout << "起始地址：" << p->data.address << endl;
cout << "分区大小：" << p->data.size << " KB" << endl;
cout << "状    态：";
if (p->data.state == Free) cout << "空  闲" << endl;
else cout << "已分配" << endl;
cout << "——————————————" << endl;
p = p->next;
}
}


//----------------------- 主  函  数---------------------------
void main()
{
int ch;//算法选择标记
cout << "       动态分区分配方式的模拟       \n";
cout << "************************************\n";
cout << "** 1)首次适应算法  2)最佳适应算法 **\n";
cout << "************************************\n";
cout << "请选择分配算法：";
cin >> ch;
Initblock(); //开创空间表
int choice;  //操作选择标记
while (1)
{
cout << "********************************************\n";
cout << "**    1: 分配内存        2: 回收内存      **\n";
cout << "**    3: 查看分配        0: 退    出      **\n";
cout << "********************************************\n";
cout << "请输入您的操作 ：";
cin >> choice;
if (choice == 1) alloc(ch); // 分配内存
else if (choice == 2)  // 内存回收
{
int ID;
cout << "请输入您要释放的分区号：";
cin >> ID;
free(ID);
}
else if (choice == 3) show();//显示主存
else if (choice == 0) break; //退出
else //输入操作有误
{
cout << "输入有误，请重试！" << endl;
continue;
}
}

}

二：首次适应算法

动态分区分配算法

一、实验内容

编写一个内存动态分区分配模拟程序，模拟内存的分配和回收的完整过程。

二、实验目的

主存的分配和回收的实现与主存储器的管理方式有关的，通过本实验帮助学生理解在可变分区管理方式下应怎样实现主存空间的分配和回收。

三、实验原理

模拟在可变分区管理方式下采用最先适应算法实现主存分配和回收。

(1)可变分区方式是按作业需要的主存空间大小来分割分区的。当要装入一个作业时，根据作业需要的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入。随着作业的装入、撤离，主存空间被分成许多个分区，有的分区被作业占用，而有的分区是空闲的。例如：

 

0 5k 10k 14k 26k 32k     512k   操作系统

作业1

作业3

空闲区

作业2

空闲区

 

为了说明哪些区是空闲的，可以用来装入新作业，必须要有一张空闲区说明表，格式如下：

 

	起    址	长    度	状      态
第一栏	14 K	12 K	未 分 配
第二栏	32 K	96 K	未 分 配
M	M	M	M

其中，起址——指出一个空闲区的主存起始地址。

     长度——指出从起始地址开始的一个连续空闲的长度。

     状态——有两种状态，一种是“未分配”状态，指出对应的由起址指出的某个长度的区域是空闲区。

 (2) 当有一个新作业要求装入主存时，必须查空闲区说明表，从中找出一个足够大的空闲区。有时找到的空闲区可能大于作业需要量，这时应把原来的空闲区变成两部分：一部分分给作业占用；另一部分又成为一个较小的空闲区。为了尽量减少由于分割造成的空闲区，而尽量保存高地址部分有较大的连续空闲区域，以利于大型作业的装入。为此，在空闲区说明表中，把每个空闲区按其地址顺序登记，即每个后继的空闲区其起始地址总是比前者大。

(3) 采用最先适应算法（顺序分配算法）分配主存空间。

按照作业的需要量，查空闲区说明表，顺序查看登记栏，找到第一个能满足要求的空闲区。当空闲区大于需要量时，一部分用来装入作业，另一部分仍为空闲区登记在空闲区说明表中。

由于本实验是模拟主存的分配，所以把主存区分配给作业后并不实际启动装入程序装入作业，而用输出“分配情况”来代替。

(4) 当一个作业执行结束撤离时，作业所占的区域应该归还，归还的区域如果与其它空闲区相邻，则应合成一个较大的空闲区，登记在空闲区说明表中。

(5) 请按最先适应算法设计主存分配和回收的程序。假设初始时主存中没有作业，现按下面序列进行内存的申请与释放：

作业1申请300K，作业2申请100K，作业1释放300K，作业3申请150K，

作业4申请30K， 作业5申请40K， 作业6申请60K， 作业4释放30K。    

一、动态内存分配的几种分配方式（具体可以点粉色字体链接）

动态内存分配有四种分配方式，本次实验采用首次适应算法

 

二、用Ｃ语言模拟实验首次适应算法

（１）说一下思路吧，我的思路是利用数据结构中的二叉树

①打印分区表的时候，只需遍历一遍二叉树，然后输出度为0的节点（没有孩子的节点）

②作业完成后，释放空间时，通过插入时候给的作业名称来遍历、寻找到该节点，将其状态修改为free即可

注意：

还有就是释放后，空闲区的合并问题。由于本次实验所插入、释放作业后，无需合并，这点在本次实验忽略（虽然题目有要求。。）

（２）代码块

[cpp] view plain copy

1. //动态内存分配   
2. #include<stdio.h>  
3. int temp=0;//定义一个全局变量！这个变量起很大作用  
4. typedef struct _BiTNode//定义 表 的结构体   
5. {  
6.     int address;//首地址   
7.     int length;//空闲区长度   
8.     bool state;//区域状态 “1”表示已分配， “0”表示未分配   
9.     int homework; //作业名   
10.     struct _BiTNode *lchild;//指向左孩子的指针   
11.     struct _BiTNode *rchild;//右孩子   
12. }BiTNode,*pBiTree;  
13. void Init_BiTree(pBiTree l)  
14. {         
15.     l->address = 5;  
16.     l->length = 507;  
17.     l->state = 0;      
18.     l->homework=NULL;  
19.     l->lchild = NULL;  
20.     l->rchild = NULL;  
21.     printf("初始化完成！\n");  
22. }   
23. int Print(pBiTree p)  
24. {     
25.     printf("\n\t\t%d\t%d\t",p->address,p->length);  
26.     if(p->state==1)  
27.         printf("Busy  \t");  
28.     else  
29.         printf("Free  \t");  
30.     if(p->homework!=0)  
31.         printf("%d\n",p->homework);  
32.     else   
33.         printf("\n");   
34. }  
35. //先序遍历    
36. void PreOrder(pBiTree p)    
37. {     
38.     if(p != NULL)    
39.     {           
40.         if(!p->lchild&&!p->rchild)        
41.             Print(p);  //输出该结点  
42.         PreOrder(p->lchild);  //遍历左子树     
43.         PreOrder(p->rchild); //遍历右子树    
44.     }    
45. }    
46. void Insert_PreOrder(pBiTree p,int length,int homework)//插入新作业    
47. {     
48.     if(p != NULL)    
49.     {       
50.         if((p->state==0)&&(length<p->length)&&(!p->lchild)&&(!p->rchild)&&temp==0)//判断节点是否有左右孩子，是否小于空闲区长度，是否状态为0（表示区域无作业运行）   
51.         {    
52.             pBiTree  x1 =new BiTNode;//进行插入，动态申请两个空间 x1,x2   
53.             pBiTree  x2 =new BiTNode;  
54.             x1->homework=homework;//x1为作业   
55.             x2->homework=NULL;//x2为剩余的空闲区   
56.             x1->address=p->address;//把原空闲区的首地址给作业的首地址   
57.             x1->state=1;//作业的状态改为1   
58.             x1->length=length;//作业的长度为传入的长度   
59.             x2->address=x1->address+length;//新空闲区的首地址为 x1首地址与x1长度之和   
60.             x2->length=p->length-x1->length;  
61.             p->lchild=x1;  
62.             p->rchild=x2;  
63.             x2->state=0;  
64.             x1->lchild=NULL;  
65.             x1->rchild=NULL;  
66.             x2->rchild=NULL;  
67.             x2->lchild=NULL;   
68.             temp=1;  
69.         }         
70.         else  
71.         {     
72.             Insert_PreOrder(p->lchild,length,homework);  //遍历左子树     
73.             Insert_PreOrder(p->rchild,length,homework); //遍历右子树    
74.         }   
75.     }    
76. }   
77. void Delect_PreOrder(pBiTree p,int homework) //遍历修改，将状态修改为0。即为空闲区   
78. {     
79.     if(p != NULL)    
80.     {           
81.         if(p->homework==homework)//当查询到作业名相同的作业。进行修改   
82.         {  
83.             p->homework=NULL;//将作业名修改为空   
84.             p->state=0;//将作业名状态修改为空闲   
85.         }     
86.     Delect_PreOrder(p->lchild,homework);  //遍历左子树     
87.     Delect_PreOrder(p->rchild,homework); //遍历右子树    
88.     }    
89. }    
90. int main()  
91. {     
92.     BiTNode l;  
93.     Init_BiTree(&l);  
94.     //初始化   
95.     printf("\n   初始化:\t首地址\t长度\t状态\t作业名\n");  
96.   
97.     PreOrder(&l);  
98.     //插入作业1   
99.     temp=0;  
100.     Insert_PreOrder(&l,300,1);  
101.     printf("\n插入作业1:\t首地址\t长度\t状态\t作业名\n");  
102.     PreOrder(&l);    
103.     //插入作业2   
104.     temp=0;  
105.     Insert_PreOrder(&l,100,2);  
106.     printf("\n插入作业2:\t首地址\t长度\t状态\t作业名\n");  
107.     PreOrder(&l);  
108.     //释放作业1   
109.     Delect_PreOrder(&l,1);   
110.     printf("\n释放作业1:\t首地址\t长度\t状态\t作业名\n");  
111.     PreOrder(&l);     
112.     //插入作业3   
113.     temp=0;  
114.     Insert_PreOrder(&l,150,3);  
115.     printf("\n插入作业3:\t首地址\t长度\t状态\t作业名\n");  
116.     PreOrder(&l);  
117.     //插入作业4   
118.     temp=0;  
119.     Insert_PreOrder(&l,30,4);  
120.     printf("\n插入作业4:\t首地址\t长度\t状态\t作业名\n");  
121.     PreOrder(&l);  
122.     //插入作业5   
123.     temp=0;  
124.     Insert_PreOrder(&l,40,5);  
125.     printf("\n插入作业5:\t首地址\t长度\t状态\t作业名\n");  
126.     PreOrder(&l);  
127.     //插入作业6   
128.     temp=0;  
129.     Insert_PreOrder(&l,60,6);  
130.     printf("\n插入作业6:\t首地址\t长度\t状态\t作业名\n");  
131.     PreOrder(&l);  
132.     //释放作业4   
133.     Delect_PreOrder(&l,4);   
134.     printf("\n释放作业4:\t首地址\t长度\t状态\t作业名\n");  
135.     PreOrder(&l);     
136.     return 0;  
137. }   

（３）执行结果

三：最佳适应算法和首次适应算法

首次适应算法：

找到第一个满足程序的内存块，并将其分配给程序

最佳适应算法：

找到所有的满足程序的内存块，并将其中最小的内存块分配给程序

[cpp] view plain copy

1. #include <iostream>  
2. #include <string.h>  
3. #include <stdio.h>  
4.   
5. using namespace std;  
6.   
7. struct node{  
8.       
9.     int st,size,num;  
10.     bool work;  
11.     node *next,*pre;  
12.     node(){  
13.         work = false;  
14.         st = 0;  
15.         next = NULL;  
16.         pre = NULL;  
17.     }  
18. }*add,*mem;  
19.   
20. int work_num,oper,Size;  
21.   
22. void show(){  
23.       
24.     printf("------------------------------------------------------------------------\n\n");  
25.       
26.     printf("\t\t当前的内存分配情况如下:\n\n");  
27.       
28.     node *now = mem;  
29.       
30.     printf("\t起始地址\t空间大小\t工作状态\t作业号\t\n\n");  
31.       
32.     while(true){  
33.         printf("\t%d\t\t%d kb\t\t%s\t\t",now->st,now->size,now->work?"Busy":"Free");  
34.         if(now->work) printf("%d\t",now->num);  
35.         printf("\n\n");  
36.         if(now->next==NULL){  
37.             break;  
38.         }  
39.         now = now->next;  
40.     }  
41.       
42.     printf("------------------------------------------------------------------------\n\n");  
43.       
44.       
45. }  
46.   
47. bool find1(){  
48.     //找最小的  
49.     node *now = mem;  
50.     node *get = NULL;  
51.     while(true){  
52.         if(!now->work){  
53.             if(now->size>=Size){  
54.                 //找出所有的可放置内存块中内存最小的  
55.                 if(get==NULL){  
56.                     get = now;  
57.                 }else{  
58.                     if(get->size > now->size){  
59.                         get = now;  
60.                     }  
61.                 }  
62.             }  
63.         }  
64.         if(now->next==NULL) break;  
65.         now = now->next;  
66.     }  
67.     // 若找不到放置位置 返回不可放置  
68.     if(get==NULL) return false;  
69.       
70.     // 更新内存情况  
71.     get->work = true;  
72.     get->num = work_num;  
73.     if(get->size>Size){  
74.         add = new node();  
75.         add->size = get->size - Size;  
76.         get->size = Size;  
77.         add->st = get->st + get->size;  
78.         add->next = get->next;  
79.         get->next = add;  
80.         add->pre = get;  
81.     }  
82.       
83.     return true;  
84. }  
85.   
86. bool find2(){  
87.     //找最前面的  
88.     node *now = mem;  
89.     while(true){  
90.         if(!now->work){  
91.             if(now->size>=Size){  
92.                 //找到第一个可放置的内存空间 更新内存状况 返回分配结果  
93.                 now->work = true;  
94.                 now->num = work_num;  
95.                   
96.                 if(now->size>Size){  
97.                     add = new node();  
98.                     add->size = now->size - Size;  
99.                     now->size = Size;  
100.                     add->st = now->st + now->size;  
101.                     add->next = now->next;  
102.                     now->next = add;  
103.                     add->pre = now;  
104.                       
105.                 }  
106.                 return true;  
107.             }  
108.         }  
109.         if(now->next==NULL) break;  
110.         now = now->next;  
111.     }  
112.     return false;  
113. }  
114.   
115. bool find(int ope){  
116.       
117.     // 分配内存操作  
118.       
119.     if(ope){  
120.         //最佳适应算法  
121.         return find1();  
122.     }else{  
123.         //首次适应算法  
124.         return find2();  
125.     }  
126. }  
127.   
128. bool reget(){  
129.       
130.     // 回收内存操作  
131.       
132.     node *now = mem;  
133.     while(true){  
134.           
135.         if(now->num==work_num&&now->work){  
136.             //找到对应工作号且在工作的内存区  
137.               
138.             node *pre = now,*next = now->next;  
139.             int pre_unused_memSize = 0,next_unused_memSize = 0;  
140.               
141.             //将空闲的内存区合并  
142.             while(pre->pre!=NULL&&!pre->pre->work){  
143.                   
144.                 pre_unused_memSize += pre->size;  
145.                 pre = pre->pre;  
146.             }  
147.             while(next!=NULL&&!next->work){  
148.                 next_unused_memSize += next->size;  
149.                 next = next->next;  
150.             }  
151.             now = pre;  
152.             now->next = next;  
153.             now->size += pre_unused_memSize + next_unused_memSize;  
154.             now->work = false;  
155.             if(next!=NULL) next->pre = now;  
156.             return true;  
157.         }  
158.           
159.         if(now->next==NULL){  
160.             break;  
161.         }  
162.         now = now->next;  
163.     }  
164.       
165.     return false;  
166. }  
167.   
168. void work(int ope){  
169.       
170.     // 执行操作  
171.       
172.     while(true){  
173.         printf("\n\t1: 分配内存  2: 回收内存  0: 退出\n\n请输入操作:");  
174.         scanf("%d",&oper);  
175.         printf("\n");  
176.         if(oper==1){  
177.               
178.             // 分配内存  
179.               
180.             printf("请输入作业号: ");  
181.             scanf("%d",&work_num);  
182.             printf("\n");  
183.             printf("请输入需要分配的内存大小(kb): ");  
184.             scanf("%d",&Size);  
185.             printf("\n");  
186.             if(find(ope)){  
187.                 printf("内存分配成功！\n\n");  
188.             }else{  
189.                 printf("内存分配失败！\n\n");  
190.             }  
191.             show();  
192.         }else if(oper==2){  
193.               
194.             // 回收内存  
195.               
196.             printf("请输入作业号: ");  
197.             scanf("%d",&work_num);  
198.             printf("\n");  
199.             if(reget()){  
200.                 printf("\t\t内存回收成功！\n\n");  
201.             }else{  
202.                 printf("\t\t内存回收失败！\n\n");  
203.             }  
204.             show();  
205.         }else{  
206.             // 操作结束  
207.               
208.             break;  
209.         }  
210.     }  
211. }  
212.   
213. void delete_mem(node *now){  
214.     // 清空内存  
215.     if(now->next!=NULL) delete_mem(now->next);  
216.     delete now;  
217. }  
218.   
219. int main()  
220. {  
221.       
222.     int ope;  
223.     while(true){  
224.         printf("\t\t请选择需要模拟的分配算法\n\n\t\t0\t首次适应算法\n\n\t\t1\t最佳适应算法\n\n");  
225.         printf("\t\t你的选择是 : ");  
226.         scanf("%d",&ope);  
227.         printf("\n");  
228.         mem = new node(); mem->size = 1000;  
229.         if(ope){  
230.             //最佳适应算法  找到最小可存储空间  
231.             work(ope);  
232.             printf("\t\t最佳适应算法模拟结束\n\n\n");  
233.             printf("-----------------------------------------------------------------------\n\n");  
234.         }else{  
235.             //首次适应算法  找到第一个可存储空间  
236.             work(ope);  
237.             printf("\t\t首次适应算法模拟结束\n\n\n");  
238.             printf("-----------------------------------------------------------------------\n\n");  
239.         }  
240.         delete_mem(mem);  
241.     }  
242.     return 0;  
243. }  

四：首次适应算法和最佳适应算法

1. #include <stdio.h>  
2. #define getpch(type) (type*)mallloc(sizeof(type))  
3. strct LNode  
4. {  
5.     int size;  
6.     int start;  
7.     int end;  
8.     struct LNode *next;  
9.     struct LNode *front;  
10. }*L;  
11. typedeft struct LNode LN;  
12. LN *find;  
13. int n;  
14. void InsertList(int size,int start)  
15. {  
16.     LN *p,*s,*t;  
17.     p=L;  
18.     printf("\n空闲区号 长度 起始位置 终止位置\n");  
19.     for(i=1;i<=n;i++)  
20.     {  
21.         printf("%3d\t %3d\t%3d\t %4d\n",i,p->size,p->start,p->end);  
22.         p=p->next;  
23.     }  
24. }  
25.   
26. void BFSortList()  
27. {  
28.     LN *p,*s,*t;  
29.     int min_size,i;  
30.     int size,start,end;  
31.     t=L->next;  
32.     p=L->next;  
33.     for(i=0;i<n;i++)  
34.         {  
35.             s=p->next;  
36.             min_size=p->size;  
37.             while(s)  
38.             {  
39.                 if(min_size>s->size)  
40.                 {  
41.                     min_size=s->size;  
42.                     t=s;  
43.                 }  
44.                 s=s->next;  
45.             }  
46.             size=t->size;  
47.             start=t->start;  
48.             end=t->end;  
49.             t->size=p->size;  
50.             t->start=p->start;  
51.             t->end=p->end;  
52.             p->size=size;  
53.             p->start=start;  
54.             p->end=end;  
55.             t=->next;  
56.             p=p->next;  
57.         }  
58. }  
59.   
60. void SortList()  
61. {  
62.     LN *p.*s,*t;  
63.     int min_start,i;  
64.     int size,start,end;  
65.     t=L->next;  
66.     p=L->next;  
67.     for(i=0;i<n;i++)  
68.         {  
69.             s=p->next;  
70.             min_start=p->start;  
71.             while(s)  
72.             {  
73.                 if(min_start>s->start)  
74.                 {  
75.                     min_start=s->start;  
76.                     t=s;  
77.                 }  
78.                 s=s->next;  
79.             }  
80.             size=t->size;  
81.             start=t->start;  
82.             end=t->end;  
83.             t->size=p->size;  
84.             t->start=p->start;  
85.             t->end=p->end;  
86.             p->size=size;  
87.             p->start=start;  
88.             p->end=end;  
89.             t=->next;  
90.             p=p->next;  
91.         }  
92. }  
93.   
94. void GetFree()  
95. {  
96.     int size,start,i;  
97.     L=getpch(LN);  
98.     L->next=NULL;  
99.     L->front=NULL;  
100.     printf("请输入空闲区数：");  
101.     scanf("%d",&n);  
102.     for(i=1;i<=n;i++)  
103.     {  
104.         printf("请输入第%2d空闲区的大小和初始地址。\n",i);  
105.         scanf("%3d,%3d",&size,&start);  
106.         InsertList(size,start);  
107.     }  
108.     printf("\n按任意键继续。");  
109. }  
110.   
111. void Assign(int size)  
112. {  
113.     LN *p,*t;  
114.     p=L->next;  
115.     t=L;  
116.     while(p)  
117.     {  
118.         p=p->next;  
119.         t=t->next;  
120.         if(!p)  
121.         {  
122.             printf("没有足够大的空间。\n");  
123.         }  
124.         else  
125.         {  
126.             p->size=p->size-size;  
127.             p->start=p->start+size;  
128.             if(p->size==0)  
129.             {  
130.                 t->next=p->next;  
131.                 p->next->front=t;  
132.                 n--;  
133.                 free(p);  
134.             }  
135.         }  
136.         printf("分配成功！\n");  
137.         printf("分配后的空闲链表情况如下：\n");  
138.         PrintList();  
139.         break;  
140.     }  
141. }  
142.   
143. int flag=-1;  
144.   
145. void NF_Assign(int size)  
146. {  
147.     LN *P,*t;  
148.     int i=n;  
149.     p=find->next;  
150.     t=find;  
151.     while(p)  
152.     {  
153.         if(size>p->size)  
154.         {  
155.             p=p->next;  
156.             t=t->next;  
157.             if(!p)  
158.             {  
159.                 printf("没有足够大的空间去分配！分配不成功。");  
160.             }  
161.         }  
162.         else  
163.         {  
164.             p->size=p->size-size;  
165.             p->start=p->start+size;  
166.             find=p;  
167.             if(p->size==0)  
168.             {  
169.                 t->next=p->next;  
170.                 p->next-front=t;  
171.                 n--;  
172.                 free(p);  
173.             }  
174.             printf("分配成功！\n");  
175.             flag=1;  
176.             printf("分配后的空闲链表情况如下：\n");  
177.             Print(L);  
178.             break;  
179.         }  
180.     }  
181.     if(flag==-1)  
182.     {  
183.         p=L->next;  
184.         t=L;  
185.         while(p!=find)  
186.         {  
187.             if(size>p->size)  
188.             {  
189.                 p=p->size;  
190.                 t=t->next;  
191.                 if(!p)  
192.                 {  
193.                     printf("没有足够大的空间去分配！分配不成功。");  
194.                 }  
195.             }  
196.             else  
197.             {  
198.                 p->size=p->size-size;  
199.                 p->start=p->start+size;  
200.                 find=t;  
201.                 if(p->size==0)  
202.                 {  
203.                     t->next=p->next;  
204.                     p->next-front=t;  
205.                     n--;  
206.                     free(p);  
207.                 }  
208.                 printf("分配成功！\n");  
209.                 printf("分配后的空闲链表情况如下：\n");  
210.                 PrintList(L);  
211.                 break;  
212.             }  
213.         }  
214.     }  
215. }  
216.   
217. void Recover(int start,int end)  
218. {  
219.     LN *p,*t;  
220.     int size,flag=0;  
221.     size=end-start;  
222.     p=L->next;  
223.     t=p->next;  
224.     while(p)  
225.     {  
226.         if(t&&p->end==start&&t->start==end)  
227.         {  
228.             p->size=p->size+size+t->size;  
229.             p->end=t->end;  
230.             p->next=t->next;  
231.             t->next->front=p;  
232.             free(t);  
233.             n--;  
234.             SortList(L);  
235.             flag=1;  
236.             break;  
237.         }  
238.         else if(p->end==start)  
239.         {  
240.             flag=1;  
241.             p->size=p->size+size;  
242.             p->end=p->end+size;  
243.             SortList(L);  
244.             break;  
245.         }  
246.         else if(p->start==end)  
247.         {  
248.             p->size=p->size+size;  
249.             p->start=start;  
250.             SortList(L);  
251.             flag=1;  
252.             break;  
253.         }  
254.         p=p->next;  
255.         if(p)  
256.             t=p->next;  
257.     }  
258.     if(flag==0)  
259.     {  
260.         InsertList(size，start);  
261.         n++;  
262.     }  
263.     printf("回收后的空闲链表情况如下：");  
264.     PrintList();  
265.     printf("\n按任意间继续。");  
266. }  
267.   
268. void main()  
269. {  
270.     int start,end,size;  
271.     int m;  
272.     GetFree();  
273.     getch();  
274.     system("cls");  
275.     printf("请选择服务类型：\n");  
276.     printf("\t1：首次适应算法\n");  
277.     printf("\t3：最佳适应算法\n");  
278.     printf("\t4：最佳适应算法\n");  
279.     printf("\t0：退出\n");  
280.     printf("\t输入您要的选项：\n");  
281.     scanf("%d",&m);  
282.     if(m==2)find=L;  
283.     while(m)  
284.     {  
285.         switch(m)  
286.         {  
287.             case 1:  
288.                 SortList();  
289.                 printf("\n空闲链表情况：\n");  
290.                 PrintList();  
291.                 printf("请输入进程需要的空闲区大小：");  
292.                 scanf("%d",&size);  
293.                 Assign(size);  
294.                 printf("\n按任意键继续");  
295.                 break;  
296.             case 2:  
297.                 SortList();  
298.                 printf("\n空闲链表情况：\n");  
299.                 PrintList();  
300.                 printf("请输入进程需要的空闲区大小：");  
301.                 scanf("%d",&size);  
302.                 NF_Assign(size);  
303.                 printf("\n按任意键继续");  
304.                 break;  
305.             case 3:  
306.                 BFSortList();  
307.                 printf("\n空闲链表情况：\n");  
308.                 PrintList();  
309.                 printf("请输入进程需要的空闲区大小：");  
310.                 scanf("%d",&size);  
311.                 Assign(size);  
312.                 printf("\n按任意键继续");  
313.                 break;  
314.             case 4:  
315.                 printf("请输入回收去的首地址和中止地址：");  
316.                 scanf("%3d,%3d",&start,&end);  
317.                 Recover(start,end);  
318.                 break;  
319.             case 0: exit(0);  
320.             default:printf("\n\t\t输入错误，请重新输入");getch();  
321.         }  
322.         getch();  
323.         system("cls");  
324.         printf("请选择服务类型：\n");  
325.         printf("\t1：首次适应算法\n");  
326.         printf("\t3：最佳适应算法\n");  
327.         printf("\t4：最佳适应算法\n");  
328.         printf("\t0：退出\n");  
329.         printf("\t输入您要的选项：\n");  
330.         scanf("%d",&m);  
331.     }  
332. }  

五：合集三个算法

1. /*所有的链表带有头节点，以便于排序*/  
2.   
3. #include<stdio.h>  
4. #include<stdlib.h>  
5. #include<malloc.h>  
6. #define PROCESS_NAME_LEN 32   /*进程名长度*/  
7. #define MIN_SLICE    10             /*最小碎片的大小*/  
8. #define DEFAULT_MEM_SIZE 1024     /*内存大小*/  
9. #define DEFAULT_MEM_START 0       /*起始位置*/  
10. /* 内存分配算法 */  
11. #define MA_FF 1  
12. #define MA_BF 2  
13. #define MA_WF 3  
14. int mem_size = DEFAULT_MEM_SIZE; /*内存大小*/  
15. int ma_algorithm = MA_FF;           /*当前分配算法*/  
16. static int pid = 0;                                      /*初始pid*/  
17. int flag = 0;                             /*设置内存大小标志*/  
18.   
19.   
20.   
21.   
22. /*描述每一个空闲块的数据结构*/  
23. struct free_block_type {  
24.     int size;  
25.     int start_addr;  
26.     struct free_block_type *next;  
27. };  
28. /*指向内存中空闲块链表的首指针*/  
29. struct free_block_type *free_block;  
30. /*每个进程分配到的内存块的描述*/  
31. struct allocated_block {  
32.     int pid;  
33.     int size;  
34.     int start_addr;  
35.     char process_name[PROCESS_NAME_LEN];  
36.     struct allocated_block *next;  
37. };  
38. /*进程分配内存块链表的首指针*/  
39. struct allocated_block *allocated_block_head = NULL;  
40.   
41.   
42.   
43. //函数声明  
44. void display_menu();  
45. int set_mem_size();  
46. void set_algorithm();  
47. void rearrange(int algorithm);  
48. int new_process();  
49. int allocate_mem(struct allocated_block *ab);  
50. void kill_process();  
51. int free_mem(struct allocated_block *ab);  
52. int dispose(struct allocated_block *free_ab);  
53. int display_mem_usage();  
54. //allocated_block* find_process(int pid);  
55. void rearrange_FF();  
56. void rearrange_BF();  
57. void rearrange_WF();  
58.   
59. /*按FF算法重新整理内存空闲块链表*/  
60. void rearrange_FF()  
61. {  
62.     //请自行补充 m代表头，p。q分别代表交换的两个节点 n代表交换截至位置  
63.     struct free_block_type *p, *q, *m, *n;  
64.   
65.       
66.     if ( free_block->next->next != NULL)  
67.     {  
68.         n = NULL;  
69.         while (n != free_block->next->next)  
70.         {  
71.             m = free_block;  
72.             p = free_block->next;  
73.             q = p->next;  
74.             while (q != n)  
75.             {  
76.                 if (p->start_addr > q->start_addr)  
77.                 {  
78.                     p->next = q->next;  
79.                     q->next = p;  
80.                     m->next = q;  
81.                 }  
82.                 m = m->next;  
83.                 p = m->next;  
84.                 q = p->next;  
85.             }  
86.             n = p;  
87.         }  
88.     }  
89.   
90.   
91. }  
92. /*按BF算法重新整理内存空闲块链表*/  
93. void rearrange_BF()  
94. {  
95.     //请自行补充  
96.   
97.         //请自行补充 m代表头，p。q分别代表交换的两个节点 n代表交换截至位置  
98.     struct free_block_type *p, *q, *m, *n;  
99.   
100.     if (free_block->next->next != NULL)  
101.     {  
102.         n = NULL;  
103.         while (n != free_block->next->next)  
104.         {  
105.             m = free_block;  
106.             p = free_block->next;  
107.             q = p->next;  
108.             while (q != n)  
109.             {  
110.                 if (p->size > q->size)  
111.                 {  
112.                     p->next = q->next;  
113.                     q->next = p;  
114.                     m->next = q;  
115.                 }  
116.                 m = m->next;  
117.                 p = m->next;  
118.                 q = p->next;  
119.   
120.   
121.             }  
122.             n = p;  
123.         }  
124.     }  
125. }  
126. /*按WF算法重新整理内存空闲块链表*/  
127. void rearrange_WF()  
128. {  
129.     //请自行补充  
130.             //请自行补充 m代表头，p。q分别代表交换的两个节点 n代表交换截至位置  
131.     struct free_block_type *p, *q, *m, *n;  
132.   
133.     if (free_block->next->next != NULL)  
134.     {  
135.         n = NULL;  
136.         while (n != free_block->next->next)  
137.         {  
138.             m = free_block;  
139.             p = free_block->next;  
140.             q = p->next;  
141.             while (q != n)  
142.             {  
143.                 if (p->size < q->size)  
144.                 {  
145.                     p->next = q->next;  
146.                     q->next = p;  
147.                     m->next = q;  
148.                 }  
149.                 m = m->next;  
150.                 p = m->next;  
151.                 q = p->next;  
152.             }  
153.             n = p;  
154.         }  
155.     }  
156. }  
157.   
158. //查找进程  
159. struct allocated_block* find_process(int pid)  
160. {  
161.     struct allocated_block *abb;  
162.     for (abb = allocated_block_head->next; abb && abb->pid != pid; abb = abb->next);  
163.     return abb;  
164. }  
165.   
166. //释放内存  
167. int free_mem(struct allocated_block *ab)  
168. {  
169.     struct free_block_type * p;  
170.     //分配空闲分区表的中的一个节点  每一次选择头节点后后面插入，并且完成之后查看当前算法，重新整理链表  
171.     p = (struct free_block_type *)malloc(sizeof(struct free_block_type));  
172.     p->next = free_block->next;  
173.     free_block->next = p;  
174.     p->size = ab->size;  
175.     p->start_addr = ab->start_addr;  
176.     return 1;  
177. }  
178.   
179. //释放要杀死进程的节点  
180. int dispose(struct allocated_block *ab)  
181. {  
182.     struct allocated_block *p;  
183.     for (p = allocated_block_head; p && p->next != ab; p = p->next);  
184.     p->next = ab->next;  
185.     free(ab);  
186.     return 1;  
187. }  
188.   
189. //杀死进程  
190. void kill_process()  
191. {  
192.     struct allocated_block *ab;  
193.     int pid;  
194.     printf("Kill Process, pid=");  
195.     scanf("%d", &pid);  
196.     getchar();  
197.     ab = find_process(pid);  
198.     if (ab != NULL)  
199.     {  
200.         free_mem(ab);  
201.         dispose(ab);  
202.     }  
203. }  
204.   
205.   
206. int allocate_mem(struct allocated_block *ab)  
207. {  
208.     struct free_block_type *p, *q, *temp;  
209.     int sum = 0;  
210.     if (free_block->next == NULL)  
211.     {  
212.         printf("no  memory");  
213.         return;  
214.     }  
215.     //当前算法进行整理内存  
216.     rearrange(ma_algorithm);  
217.   
218.   
219.     //根据当前算法在空闲分区链表中搜索合适空闲分区进行分配，分配时注意以下情况：  
220.     // 1. 找到可满足空闲分区且分配后剩余空间足够大，则分割  
221.     // 2. 找到可满足空闲分区且但分配后剩余空间（最小碎片化）比较小，则一起分配  
222.     // 3. 找不可满足需要的空闲分区但空闲分区之和能满足需要，则采用内存紧缩技术，进行空闲分区的合并，然后再分配  
223.     // 4. 在成功分配内存后，应保持空闲分区按照相应算法有序  
224.     // 5. 分配成功则返回1，否则返回-1  
225.   
226.     //如果首次适应 和最佳适应差不多 从链首开始查找，如果找到，则开始分配，如果没有找到，采用分区紧缩技术，如果可以分配，则分配，不能分配，返回-1  
227.     if (ma_algorithm == MA_FF || ma_algorithm == MA_BF)  
228.     {  
229.         //开始寻找符合条件的节点  
230.         for (p = free_block, q = p->next; q && q->size < ab->size; p = p->next, q = p->next);  
231.   
232.         //找到  
233.         if (q)  
234.         {  
235.             //判断是否达到最小碎片程度  
236.   
237.             if ((q->size - ab->size) <= MIN_SLICE)  
238.             {  
239.                 //全部分配  
240.                 ab->start_addr = q->start_addr;  
241.                 ab->size = q->size;  
242.                 //释放q节点  
243.                 p->next = q->next;  
244.                 free(q);  
245.             }  
246.             else  
247.             {  
248.                 ab->start_addr = q->start_addr;  
249.                 q->start_addr = q->start_addr + ab->size;  
250.                 q->size = q->size - ab->size;  
251.             }  
252.         }  
253.         //开始内存紧缩  
254.         else  
255.         {  
256.             for (q = free_block->next; q; q = q->next)  
257.             {  
258.                 sum += q->size;  
259.                 if (sum >= ab->size)  
260.                 {  
261.                     break;  
262.                 }  
263.             }  
264.             if (q)  
265.             {  
266.                 //第一个空闲分区大小更改为sum，并且除了第一个，其他结点全部删除      
267.                 free_block->next->size = sum;  
268.                 p = free_block->next;  
269.                 for (temp = p->next; temp != q; temp = p->next)  
270.                 {  
271.                     p->next = temp->next;  
272.                     free(temp);  
273.                 }  
274.                 p->next = q->next;  
275.                 free(q);  
276.   
277.                 p->start_addr = p->start_addr + ab->size;  
278.                 p->size = p->size - ab->size;  
279.                 //如果剩余空间为0 则直接释放当前的空间  
280.             }  
281.             else  
282.   
283.             {  
284.                 return -1;  
285.             }  
286.         }  
287.     }  
288.     //最差适应  
289.     else if (ma_algorithm == MA_WF)  
290.     {  
291.         //只需要找到第一个最大的空闲分区  如果满足，则分配，不满足则判断能否进行合并，如果可以，分配  
292.         if (free_block->next->size >= ab->size)  
293.         {  
294.             if (free_block->next->size - ab->size >= 10)  
295.             {  
296.                 ab->start_addr = free_block->next->start_addr;  
297.                 free_block->next->start_addr += ab->size;  
298.                 free_block->next->size -= ab->size;  
299.             }  
300.             else  
301.   
302.             {  
303.                 p = free_block->next;  
304.                 free_block->next = p->next;  
305.                 free(p);  
306.             }  
307.         }  
308.         else  
309.         {  
310.             for (q = free_block->next; q; q = q->next)  
311.             {  
312.                 sum += q->size;  
313.                 if (sum >= ab->size)  
314.                 {  
315.                     break;  
316.                 }  
317.             }  
318.   
319.             if (q)  
320.             {  
321.                 //第一个空闲分区大小更改为sum，并且除了第一个，其他结点全部删除      
322.                 free_block->next->size = sum;  
323.                 p = free_block->next;  
324.                 for (temp = p->next; temp != q; temp = p->next)  
325.                 {  
326.                     p->next = temp->next;  
327.                     free(temp);  
328.                 }  
329.                 p->next = q->next;  
330.                 free(q);  
331.   
332.                  ab->start_addr = free_block->next->start_addr;  
333.                 p->start_addr = p->start_addr + ab->size;  
334.                 p->size = p->size - ab->size;  
335.                 //如果剩余空间为0 则直接释放当前的空间  
336.             }  
337.             else  
338.   
339.             {  
340.                 return -1;  
341.             }  
342.   
343.         }  
344.     }  
345.   
346.     return 1;  
347. }  
348.   
349. //创建一个新的进程  
350. int new_process()  
351. {  
352.     struct allocated_block *ab;  
353.     int size;  
354.     int ret;  
355.     ab = (struct allocated_block *)malloc(sizeof(struct allocated_block));  
356.     if (!ab) exit(-5);  
357.     ab->next = NULL;  
358.     pid++;  
359.     sprintf(ab->process_name, "PROCESS-%02d", pid);  
360.     ab->pid = pid;  
361.     printf("Memory for %s:", ab->process_name);  
362.     scanf("%d", &size);  
363.     getchar();  
364.     if (size > 0) ab->size = size;  
365.     ret = allocate_mem(ab);  /* 从空闲区分配内存，ret==1表示分配ok*/  
366.     /*如果此时allocated_block_head尚未赋值，则赋值*/  
367.     if ((ret == 1) && (allocated_block_head->next == NULL))  
368.     {  
369.         allocated_block_head->next = ab;  
370.         return 1;  
371.     }  
372.     /*分配成功，将该已分配块的描述插入已分配链表*/  
373.     else if (ret == 1)  
374.     {  
375.         ab->next = allocated_block_head->next;  
376.         allocated_block_head->next = ab;  
377.         return 2;  
378.     }  
379.     else if (ret == -1)  
380.     {  
381.         /*分配不成功*/  
382.         printf("Allocation fail\n");  
383.         free(ab);  
384.         return -1;  
385.     }  
386.     return 3;  
387.   
388.   
389.   
390. }  
391.   
392. int set_mem_size()  
393. {  
394.     int size;  
395.     if (flag != 0)  
396.     {  //防止重复设置  
397.         printf("Cannot set memory size again\n");  
398.         return 0;  
399.     }  
400.     printf("Total memory size =");  
401.     scanf("%d", &size);  
402.     getchar();  
403.     if (size > 0)  
404.     {  
405.         mem_size = size;  
406.         free_block->next->size = mem_size;  
407.     }  
408.     flag = 1;  
409.     return 1;  
410.   
411. }  
412. void rearrange(int algorithm)  
413. {  
414.     switch (algorithm)  
415.     {  
416.     case MA_FF:  rearrange_FF(); break;  
417.     case MA_BF:  rearrange_BF(); break;  
418.     case MA_WF: rearrange_WF(); break;  
419.     }  
420. }  
421.   
422. /* 设置当前的分配算法 */  
423. void set_algorithm()  
424. {  
425.     int algorithm;  
426.     printf("----------------------------------\n");  
427.     printf("\t1 - First Fit\n");  
428.     printf("\t2 - Best Fit \n");  
429.     printf("\t3 - Worst Fit \n");  
430.     scanf("%d", &algorithm);  
431.     getchar();  
432.     if (algorithm >= 1 && algorithm <= 3)  
433.         ma_algorithm = algorithm;  
434.     //按指定算法重新排列空闲区链表  
435.     rearrange(ma_algorithm);  
436. }  
437.   
438.   
439.   
440. //释放所有链表  
441. void do_exit()  
442. {  
443.     struct free_block_type *p;  
444.     struct allocated_block *q;  
445.     p = free_block->next;  
446.     q = allocated_block_head->next;  
447.     while (free_block->next != NULL)  
448.     {  
449.         free_block->next = p->next;  
450.         free(p);  
451.         p = free_block->next;  
452.     }  
453.     free(free_block);  
454.   
455.     while (allocated_block_head->next)  
456.     {  
457.         allocated_block_head->next = q->next;  
458.         free(q);  
459.         q = allocated_block_head->next;  
460.     }  
461.     free(allocated_block_head);  
462. }  
463.   
464. /*初始化空闲块，默认为一块，可以指定大小及起始地址*/  
465. struct free_block_type* init_free_block(int mem_size) {  
466.     struct free_block_type *fb, *p;  
467.     struct allocated_block * q;  
468.     fb = (struct free_block_type *)malloc(sizeof(struct free_block_type));  
469.     p = (struct free_block_type *)malloc(sizeof(struct free_block_type));  
470.     q = (struct allocated_block*)malloc(sizeof(struct allocated_block));  
471.   
472.   
473.     if (fb == NULL || p == NULL || q == NULL)  
474.     {  
475.         printf("No mem\n");  
476.         return NULL;  
477.     }  
478.     q->next = NULL;  
479.     allocated_block_head = q;  
480.     p->size = mem_size;  
481.     p->start_addr = DEFAULT_MEM_START;  
482.     p->next = NULL;  
483.   
484.     fb->next = p;  
485.     return fb;  
486. }  
487.   
488. int display_mem_usage()  
489. {  
490.     struct free_block_type *fbt = free_block->next;  
491.     struct allocated_block *ab = allocated_block_head->next;  
492.   
493.   
494.     if (fbt == NULL) return(-1);  
495.     printf("----------------------------------------------------------\n");  
496.   
497.     /* 显示空闲区 */  
498.     printf("Free Memory:\n");  
499.     printf("%20s %20s\n", "      start_addr", "       size");  
500.     while (fbt != NULL)  
501.     {  
502.         printf("%20d %20d\n", fbt->start_addr, fbt->size);  
503.         fbt = fbt->next;  
504.     }  
505.     /* 显示已分配区 */  
506.     printf("\nUsed Memory:\n");  
507.     printf("%10s %20s %10s %10s\n", "PID", "ProcessName", "start_addr", " size");  
508.     while (ab != NULL)  
509.     {  
510.         printf("%10d %20s %10d %10d\n", ab->pid, ab->process_name, ab->start_addr, ab->size);  
511.         ab = ab->next;  
512.     }  
513.     printf("----------------------------------------------------------\n");  
514.     return 0;  
515. }  
516.   
517.   
518. /*显示菜单*/  
519. void display_menu()  
520. {  
521.     printf("\n");  
522.     printf("1 - Set memory size (default=%d)\n", DEFAULT_MEM_SIZE);  
523.     printf("2 - Select memory allocation algorithm\n");  
524.     printf("3 - New process \n");  
525.     printf("4 - Terminate a process \n");  
526.     printf("5 - Display memory usage \n");  
527.     printf("0 - Exit\n");  
528. }  
529.   
530.   
531.   
532. int main(void)  
533. {  
534.     char choice;      pid = 0;  
535.     free_block = init_free_block(mem_size); //初始化空闲区  
536.   
537.     while (1)  
538.     {  
539.         display_menu(); //显示菜单  
540.         fflush(stdin);  
541.         choice = getchar();  
542.         fflush(stdin);  
543.         //获取用户输入  
544.         switch (choice)  
545.         {  
546.         case '1': set_mem_size(); break;    //设置内存大小  
547.         case '2': set_algorithm(); flag = 1; break;//设置算法  
548.         case '3': new_process(); flag = 1; break;//创建新进程  
549.         case '4': kill_process(); flag = 1;   break;//删除进程  
550.         case '5': display_mem_usage();    flag = 1; break;  //显示内存使用  
551.         case '0': do_exit(); exit(0);   //释放链表并退出  
552.         default: break;  
553.         }  
554.     }  
555.     return 0;  
556. }