动态分区算法

于 2024-04-09 12:21:23 发布
阅读量757 收藏 15
点赞数 21
分类专栏： java，c，数据结构等相关作业 文章标签： java jvm 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62075168/article/details/137546303
版权

一个不知名大学生，江湖人称菜狗
original author: Jacky Li
Email : 3435673055@qq.com

Time of completion：2024.04.09
Last edited: 2024.04.09

目录

动态分区算法

第1关：首次适应算法

任务描述

相关知识

内存分配

内存回收

编程要求

测试说明

代码如下

第2关：最佳适应算法

相关知识

内存分配

内存回收

编程要求

测试说明

代码如下

动态分区算法

第1关：首次适应算法

任务描述

假设初始状态下可用的内存空间为55MB，并有如下的请求序列： 作业1申请15MB 作业2申请30MB 作业1释放15MB 作业3分配8MB 作业4分配6MB 作业2释放30MB 请采用首次适应算法进行内存块的分配和回收，并打印出空闲内存分区链的情况

相关知识

为了完成本关任务，你需要掌握使用首次适应算法进行内存块的分配与回收。

内存分配

空闲分区链按地址递增的顺序链接。在分配内存时，从链首开始顺序查找，直至找到一个大小能满足要求的空闲分区。然后再按照作业的大小，从该分区中划出一块内存空间，分配给请求者，余下的空闲分区仍留在空闲链中。若从链首到链尾都找不到一个能满足要求的分区，则表明系统没有足够大的内存分配给该进程，内存分配失败返回。

内存回收

当进程运行完毕释放内存时，系统根据回收区的首址，从空闲区链(表)中找到相应的插入点，此时可能出现以下四种情况之一： (1) 回收区与插入点的前一个空闲分区F1相邻接，此时应将回收区与插入点的前一分区合并，不必为回收分区分配新表项，而只需修改其前一分区F1的大小。 (2) 回收分区与插入点的后一空闲分区F2相邻接，此时也可将两分区合并，形成新的空闲分区，但用回收区的首址作为新空闲区的首址，大小为两者之和。 (3) 回收区同时与插入点的前、后两个分区F1和F2邻接，此时将三个分区合并，使用F1的表项和F1的首址，取消F2的表项，大小为三者之和。 (4) 回收区前后没有空闲分区。这时应为回收区单独建立一个新表项，填写回收区的首址和大小，并根据其首址插入到空闲链中的适当位置

编程要求

空闲分区采用带头结点的双向链表来管理，主函数、链表初始化函数和打印函数已实现，只需要补充首次适应算法分配内存的函数 first_fit以及内存回收的函数recycle()即可。

bool first_fit(int id,int m_size)//使用首次适应算法给作业分配内存，id为作业号，m_size为作业大小 void recycle(int id)//回收内存,id为释放内存的作业号

测试说明

平台会对你编写的代码进行测试：

代码如下

#include <stdio.h>
#include <stdlib.h>

const int Max_length=55;//最大内存

struct areaNode//管理分区的结构体
{	
    int ID;//分区号	
    int size;//分区大小	
    int address;//分区地址	
    int flag;//使用状态，0为未占用，1为已占用
};

typedef struct DuNode//双向链表结点
{ 
  struct areaNode data;//数据域	
  struct DuNode *prior;//指针域	
  struct DuNode *next;
}*DuLinkList;
DuLinkList m_head = new DuNode, m_last = new DuNode;//双向链表首尾指针
  
void init()//分区链表初始化
{	
  m_head->prior = NULL;	
  m_head->next = m_last;	
  m_last->prior = m_head;	
  m_last->next = NULL;	
  m_head->data.size = 0;	
  m_last->data.address = 0;	
  m_last->data.size = Max_length;	
  m_last->data.ID = 0;
  m_last->data.flag = 0;
}

void show()
{	
  DuNode *p = m_head->next;//指向空闲区队列的首地址	
  printf("+++++++++++++++++++++++++++++++++++++++\n");	
  while (p)	
  {		
    printf("分区号：");		
	if (p->data.ID == 0)			
	  printf("FREE\n");		
	else			
	  printf("%d\n",p->data.ID);		
	printf("分区起始地址：%d\n",p->data.address);		
	printf("分区大小：%d\n",p->data.size);		
	printf("分区状态：");		
	if (p->data.flag)			
	  printf("已被占用\n");		
	else			
	  printf("空闲\n");		
	printf("——————————————————\n");		
	p = p->next;	
  }
} 

bool first_fit(int id,int m_size)//首次适应算法,id为作业号，m_size为作业大小 
{    
    //请补充使用首次适应算法给作业分配内存的函数代码
    DuLinkList temp=(DuLinkList)malloc(sizeof(DuNode));//申请双向链表指针节点temp(*a.b=a->b) 
    DuNode *p=m_head->next;
    temp->data.ID=id;//*temp.data.ID
    temp->data.size=m_size;
    temp->data.flag=1;
    
    while(p){//循环查找 
      
        if(p->data.flag==0&&p->data.size==m_size){//p节点未占用，并且空间刚好满足 
            p->data.flag=1;
            p->data.ID=id;
           return false;
        }
        if(p->data.flag==0&&p->data.size>m_size){//p节点未占用，且空间大于所需 
            temp->next=p;
            temp->prior=p->prior;//temp 插入p之前 
            
            temp->data.address=p->data.address;//分区起始地址 
            p->prior->next=temp;
            p->prior=temp;
            p->data.address=temp->data.address+temp->data.size;
            p->data.size-=m_size;
          return false;
        }
        p=p->next;
    }
  return true;

}


void recycle(int id)//回收内存,id为释放内存的作业号 
{    
    //请补充回收作业内存的代码
    
     DuLinkList n=m_head->next ;
    while(n)
    {
       
        DuLinkList q=n->next;
        if(n->data.ID==id)
        {
            if(n->prior!=m_head&&n->prior->data.flag==0&&n->next->data.flag==0)
            {
                n->prior->data.size = n->prior->data.size+q->data.size+n->data.size;
                 q->prior= n->prior;
                 n->prior->next=q;
                 
                 if(q==m_last)
                 {
                 n->prior->next=NULL;
                 n->prior->data.ID=0;
                 }
                 delete(n);
                
            }
            else if(n->prior!=m_head&&n->prior->data.flag==0&&n->next->data.flag != 0)
            { 
                n->prior->data.size+=n->data.size;
                n->prior->next=q;
                q->prior=n->prior;
                delete n;
                break; 
            }
            else if(n->next->data.flag==0&&n->prior->data.flag!=0&&n->prior!=m_head)
            { 
              n->data.size+=q->data.size;
              n->next=q->next;
              n->data.flag=0;
              q->next->prior=n;
              delete q;
              break;
            }
            else
            {
              n->data.flag=0;
              
              break;
            }
        }
        n=n->next;
    }
    
}
int main()
{
	init();
        
    printf("首次适应算法：\n");
	first_fit(1,15);
	first_fit(2,30);
	recycle(1);
	first_fit(3,8);
	first_fit(4,6);
	recycle(2);
	
	show();
	
	DuNode *p = m_head;
	while(p != NULL)
	{
		DuNode *temp =  p;
		p = p->next;
		delete(temp);
		temp = NULL;
	}
	
	return 0;
}

第2关：最佳适应算法

假设初始状态下可用的内存空间为55MB，并有如下的请求序列： 作业1申请15MB 作业2申请30MB 作业1释放15MB 作业3分配8MB 作业4分配6MB 作业2释放30MB 请采用最佳适应算法进行内存块的分配和回收，并打印出空闲内存分区链的情况

相关知识

为了完成本关任务，你需要掌握使用最佳适应算法进行内存块的分配与回收。

内存分配

每次为作业分配内存时，总是把能满足要求、又是最小的空闲分区分配给作业，避免“大材小用”。若从链首到链尾都找不到一个能满足要求的分区，则表明系统没有足够大的内存分配给该进程，内存分配失败返回。

内存回收

当进程运行完毕释放内存时，系统根据回收区的首址，从空闲区链(表)中找到相应的插入点，此时可能出现以下四种情况之一： (1) 回收区与插入点的前一个空闲分区F1相邻接，此时应将回收区与插入点的前一分区合并，不必为回收分区分配新表项，而只需修改其前一分区F1的大小。 (2) 回收分区与插入点的后一空闲分区F2相邻接，此时也可将两分区合并，形成新的空闲分区，但用回收区的首址作为新空闲区的首址，大小为两者之和。 (3) 回收区同时与插入点的前、后两个分区F1和F2邻接，此时将三个分区合并，使用F1的表项和F1的首址，取消F2的表项，大小为三者之和。 (4) 回收区前后没有空闲分区。这时应为回收区单独建立一个新表项，填写回收区的首址和大小，并根据其首址插入到空闲链中的适当位置

编程要求

空闲分区采用带头结点的双向链表来管理，主函数、链表初始化函数和打印函数已实现，只需要补充最佳适应算法分配内存的函数 best_fit以及内存回收的函数recycle()即可。

bool best_fit(int id,int m_size)//使用最佳适应算法给作业分配内存，id为作业号，m_size为作业大小 void recycle(int id)//回收内存,id为释放内存的作业号

测试说明

平台会对你编写的代码进行测试：

代码如下

#include <stdio.h>
#include <stdlib.h>

const int Max_length=55;//最大内存

struct areaNode//管理分区的结构体
{	
    int ID;//分区号	
    int size;//分区大小	
    int address;//分区地址	
    int flag;//使用状态，0为未占用，1为已占用
};

typedef struct DuNode//双向链表结点
{ 
  struct areaNode data;//数据域	
  struct DuNode *prior;//指针域	
  struct DuNode *next;
}*DuLinkList;
DuLinkList m_head = new DuNode, m_last = new DuNode;//双向链表首尾指针
  
void init()//分区链表初始化
{	
  m_head->prior = NULL;	
  m_head->next = m_last;	
  m_last->prior = m_head;	
  m_last->next = NULL;	
  m_head->data.size = 0;	
  m_last->data.address = 0;	
  m_last->data.size = Max_length;	
  m_last->data.ID = 0;
  m_last->data.flag = 0;
}

void show()
{	
  DuNode *p = m_head->next;//指向空闲区队列的首地址	
  printf("+++++++++++++++++++++++++++++++++++++++\n");	
  while (p)	
  {		
    printf("分区号：");		
	if (p->data.ID == 0)			
	  printf("FREE\n");		
	else			
	  printf("%d\n",p->data.ID);		
	printf("分区起始地址：%d\n",p->data.address);		
	printf("分区大小：%d\n",p->data.size);		
	printf("分区状态：");		
	if (p->data.flag)			
	  printf("已被占用\n");		
	else			
	  printf("空闲\n");		
	printf("——————————————————\n");		
	p = p->next;	
  }
} 


bool best_fit(int id, int m_size)//最佳适应算法，其中需要查找最佳的存放位置
{	
    //请补充使用最佳适应算法给作业分配内存的函数代码
    
    DuLinkList m = new DuNode;
	DuNode *p = m_head->next; 
	DuNode *q;
	int min=1000;
	while(p)
	{
		
		if(p->data.flag==0) 
		{
			int size=p->data.size-m_size;
			if(size<min&&size>0) 
			{
				q=p;
				min = size;
			}
		}
		p=p->next;
	 }
	m->prior= q->prior;
	q->prior->next=m;
	m->next=q;
	q->prior =m;
	
	m->data.flag=1;
	if(m->prior==m_head)
	m->data.address= 0;
	else
	m->data.address=m->prior->data.address+m->prior->data.size;
	
	m->data.ID=id;
	m->data.size=m_size;
	
	q->data.address=m->data.address+m->data.size;
	q->data.ID=0;
	q->data.size = q->data.size-m_size; 
	
	 
	
}
	



void recycle(int id)//回收内存,id为释放内存的作业号 
{	
    //请补充回收作业内存的函数代码
     DuLinkList n=m_head->next ;
    while(n)
    {
       
        DuLinkList q=n->next;
        if(n->data.ID==id)
        {
            if(n->prior!=m_head&&n->prior->data.flag==0&&n->next->data.flag==0)
            {
                n->prior->data.size = n->prior->data.size+q->data.size+n->data.size;
                 q->prior= n->prior;
                 n->prior->next=q;
                 
                 if(q==m_last)
                 {
                 n->prior->next=NULL;
                 n->prior->data.ID=0;
                 }
                 delete(n);
                
            }
            else if(n->prior!=m_head&&n->prior->data.flag==0&&n->next->data.flag != 0)
            { 
                n->prior->data.size+=n->data.size;
                n->prior->next=q;
                q->prior=n->prior;
                delete n;
                break; 
            }
            else if(n->next->data.flag==0&&n->prior->data.flag!=0&&n->prior!=m_head)
            {
              n->data.size+=q->data.size;
              n->next=q->next;
              n->data.flag=0;
              q->next->prior=n;
              delete q;
              break;
            }
            else
            {
              n->data.flag=0;
              
              break;
            }
        }
        n=n->next;
    }
    
}

int main()
{
	init();
	 
    //最佳适应算法
	printf("最佳适应算法：\n");
	init();
	best_fit(1,15);
	best_fit(2,30);
	recycle(1);
	best_fit(3,8);
	best_fit(4,6);
	recycle(2); 
	

	show();
	
	DuNode *p = m_head;
	while(p != NULL)
	{
		DuNode *temp =  p;
		p = p->next;
		delete(temp);
		temp = NULL;
	}
	
	return 0;
}

羁旅少年
关注
  • 21
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
存储管理：最佳适应算法代码解析
星辰大海的博客
07-21 898
算法流程图： 逐段解析代码： 头文件和自定义数据结构 #include<stdio.h> #include <dos.h> #include<stdlib.h> #include <conio.h> #define n 10 //假定系统允许的最大作业数为n，假定模拟实验中n值为10 #define m 10 //假定系统允许的空闲区表最大为m，假定模拟实验中m值为10 #define minisize 100 /*空闲分区被分配时， .
头歌动态分区算法第2关：最佳适应算法
最新发布
python一生之敌的博客
06-01 119
头歌动态分区算法第2关：最佳适应算法
内存管理-最先适应算法和最佳适应算法-模拟程序
05-10
设计了一个内存管理模拟程序，实现了最先适应算法和最佳适应算法，可以手动申请内存大小，释放内存，同时附有测试程序，可设置测试次数，同时统计了平均申请内存大小，内存利用率及运行时间。
动态分区算法关于首次适应算法实现（头歌实验）
weixin_67644152的博客
03-27 1400
假设初始状态下可用的内存空间为55MB，并有如下的请求序列：作业1申请15MB作业2申请30MB作业1释放15MB作业3分配8MB作业4分配6MB作业2释放30MB请采用首次适应算法进行内存块的分配和回收，并打印出空闲内存分区链的情况。
内存分配---FF、BF、WF三种算法
weixin_30878501的博客
05-20 3901
动态分区分配是根据进程的实际需要，动态的为之分配内存空间。而在实现可变分区分配时，将涉及到分区分配中 所用的数据结构、分区分配算法和分区的分配与内存回收的过程。 分区分配中的数据结构：（1）描述空闲块的数据结构。（2）内存块的描述。 #define PROCESS_NAME_LEN 32 //进程名长度 #define MIN_SLICE 10 ...
操作系统--03内存管理
weixin_45229936的博客
09-16 1230
3.1.4 连续分配管理方式—实现内存空间的分配和回收，功能一 连续分配：指为用户进程分配的必须是一个连续的内存空间 单一连续分配： 设计思想：内存被分为系统区和用户区。系统区通常位于内存的低地址部分，用户存放操作系统的相关数据；用户区存放用户进程相关数据。内存中同一时刻只能有一道用户程序，用户程序独占整个用户区。 优点：实现简单，无外部碎片。可以采用覆盖技术扩充内存，不一定需要采取内存保护。 缺点：只支持单用户、单任务的操作系统。会产生内部碎片，内部碎片指的没有用上的内存空间。存储器利用率低。 固定分区分
头歌实验8：动态分区算法（编程实验）
qq_62791684的博客
11-28 4791
头歌实验8：动态分区算法（编程实验）
动态分区分配算法
热门推荐
Become hunger become strong
04-16 2万+
基于顺序搜索的动态分区分配算法1.首次适应算法(FF)：所谓的首次的意思以地址递增链接。因此在分配内存的时候，从链首开始查找，直到找到一个大小能满足要求的空闲分区为之。 2.循环首次适应算法(NF)：和首次适应算法的区别就是，在为进程分配内存空间的时候，不再是都从链首开始查找， 而是从上次找到的空闲的分区的下一个空闲分区开始查找，直到找到一个能满足要求的空闲分区。 3.最佳适应算法(BF)：将所
内存动态分区算法.doc
07-04
"内存动态分区算法" 内存动态分区算法是操作系统存储器管理中的一种重要算法，用于实现内存的动态分区分配和回收。本文将详细介绍内存动态分区算法的设计思想、系统平台、算法描述、源程序清单等。 设计思想： 本...
实验二 实现动态分区分配模拟程序
12-31
实验内容： 编写一个动态分区分配算法模拟程序，加深对动态分区存储管理方式及其实现过程的理解。 要求： 1.空闲分区通过空闲区链进行管理，在内存分配时，优先考虑低地址部分的空闲区。 2.分别采用首次适应算法、最佳适应算法和最坏适应算法模拟内存空间的动态分配与回收，每次分配和回收后显示出空闲区链的详细情况（说明：在申请不成功时，需要打印当前内存的占用情况信息）。 3.进程对内存空间的申请和释放可由用户自定义输入。 4.参考请求序列如下： (1) 初始状态下可用内存空间为640KB； (2) 进程1申请130KB； (3) 进程2申请60KB； (4) 进程3申请100K
操作系统内存管理模拟系统实验说明书
01-06
用LINUX或者UNIX来实现操作系统内存管理模拟系统实验说明书。
动态分区分配算法-实验报告.docx
03-26
动态分区分配算法-实验报告.
操作系统——实验五 动态分区分配算法的模拟
08-05
用C/C++实现一个完整的（可变）动态分区管理器，包括分配，回收，分区碎片整理等。希望同学们实现如下功能： 初始化功能：内存状态设置为初始状态。 分配功能：要求至少使用两种算法，用户可以选择使用。 回收...
动态分区算法(操作系统)
02-17
动态分区算法是操作系统中内存管理的一种策略，它主要用于在多用户、多任务环境下分配和管理大块内存。这种算法在操作系统课程设计中占有重要地位，因为它涉及到如何有效地为不同的进程分配内存空间，确保系统的高效...
头歌——最佳适应算法
m0_63128742的博客
12-07 696
假设初始状态下可用的内存空间为55MB，并有如下的请求序列： 作业1申请15MB 作业2申请30MB 作业1释放15MB 作业3分配8MB 作业4分配6MB 作业2释放30MB 请采用最佳适应算法进行内存块的分配和回收，并打印出空闲内存分区链的情况。
动态分区算法（头歌实验）第1关：首次适应算法。第2关：最佳适应算法。
m0_65420451的博客
11-18 5401
动态分区算法（头歌实验）第1关：首次适应算法。第2关：最佳适应算法。假设初始状态下可用的内存空间为55MB，并有如下的请求序列： 作业1申请15MB 作业2申请30MB 作业1释放15MB 作业3分配8MB 作业4分配6MB 作业2释放30MB 请采用首次适应算法进行内存块的分配和回收，并打印出空闲内存分区链的情况。
存储管理之分配算法
Chen_dSir的博客
10-25 3460
操作系统之存储管理 分配算法: 1.最佳适应法 最佳适应算法要求空闲区按大小递增的次序排列.在进行内存分配时,从空闲分区表首开始顺序查找,直到找到第一个能满足其大小要求的空闲区为止,如果该空闲区大于请求表中的请求长度,则将剩余空闲区留在可用表中(如果相邻有空闲区,则与之和并),然后修改相关表的表项.按这种方式为作业分配内存,就能把既满足要求又与作业大小接近的空闲分区分配给作业.如果空闲区大
动态分区算法实验
05-24
动态分区算法是内存管理中常用的一种算法，它的主要思想是根据进程的需要动态地分配内存，以满足进程的需求。下面是一个简单的动态分区算法实验。 实验环境： - 操作系统：Windows/Linux - 编程语言：C/C++ 实验...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

羁旅少年

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值