分区匹配算法（操作系统）

最新推荐文章于 2022-05-15 23:59:23 发布
最新推荐文章于 2022-05-15 23:59:23 发布
阅读量743 收藏 4
点赞数

一、首次适应算法（First Fit） 
算法描述：

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

该算法倾向于优先利用内存中的低址部分的空闲分区，从而保留了高址部分的大空闲分区，这为以后到达的大作业分配大的内存空间创造了条件。其缺点是低值部分不断被划分，会留下许多难以利用的，很小的空闲分区，称为碎片。而每次查找又都是从低址部分开始的，这无疑又会增加查找可用空闲分区的开销。

算法实现：

/*
 *模拟首次适应算法
 */
 #include<stdio.h>
 #include<malloc.h>

 typedef struct node //定义空闲分区
 {
     int head_addr , tail_addr ; //定义当前分区的起始地址
     int memory_size ; //分区大小
     struct node *next ; //指向下一个空闲分区的指针
 } MemoryNode ;

 typedef struct //定义空闲分区链表的数据结构
 {
     MemoryNode *head , *tail ; //指向分区链表的头尾指针
 } PartitionTable ;

 /*
  *初始化系统当前分区
  */
bool init_memory(PartitionTable *pt) ;

/*
 *进行当前分区链表的扫描操作
 */
void scan_memory(PartitionTable *pt) ;

/*
 *内存空间的分配函数，首次适应算法
 */
bool first_in(PartitionTable *pt , int memory) ;
 /*
  *测试主函数
  */
int main()
{
    PartitionTable *pt ;

    int memory ;

    pt = (PartitionTable*)malloc(sizeof(PartitionTable)) ;
    if(pt == NULL)
    {
        printf("The memory is not enough ! \n") ;
        exit(0) ;
    }
    pt->head = NULL ;
    pt->tail = NULL ;

    if(! init_memory(pt))
    {
        printf("The memory deliever failed ! \n") ;
        exit(0) ;
    }

    scan_memory(pt) ;
    while(true)
    {
        printf("Please input the memory request : ") ;
        scanf("%d" , &memory) ;
        if(first_in(pt , memory))
        {
            printf("The memory deliever success ! \n") ;
        }
        else
        {
            printf("The memory deliever failed ! \n") ;
        }
        scan_memory(pt) ;
    }
    return 0 ;
}

/*
 *初始化当前分区链表
 *对内存空间进行连续分配
 */
bool init_memory(PartitionTable *pt)
{
    //分配十个大小相等的空闲分区
    int memory_num = 10 ;

    MemoryNode *node ;

    for(int i = 0 ; i < memory_num ; i++)
    {
        node = (MemoryNode*)malloc(sizeof(MemoryNode)) ;
        if(node == NULL)
        {
          printf("The memory is not enough ! \n") ;
          return false ;
        }
        node->head_addr = i * 100 ;
        node->tail_addr = (i + 1) * 100 - 1 ;
        node->memory_size = 100 ;
        node->next = NULL ;
        if(pt->head == NULL)
        {
            pt->head = pt->tail = node ;
        }
        else
        {
            pt->tail->next = node ;
            pt->tail = node ;
        }
    }
    return true ;
}

/*
 *进行当前分区的扫描操作
 */
void scan_memory(PartitionTable *pt)
{
    if(pt == NULL || pt->head == NULL)
    {
        printf("The PartitionTable is NULL ! \n") ;
        return ;
    }
    MemoryNode *node ;
    node = pt->head ;
    printf("------分区链表---------- \n") ;
    printf("head_address   tail_address   memory_size\n") ;
    while(node)
    {
        printf("  %4d            %4d           %4d \n" , node->head_addr , node->tail_addr , node->memory_size) ;
        node = node->next ;
    }
}

/*
 *首次适应算法
 */
bool first_in(PartitionTable *pt , int memory)
{
    MemoryNode *memoryNode , *preNode = NULL ;
    memoryNode = pt->head ;
    while(memoryNode)
    {
        if(memoryNode->memory_size > memory)
        {
            MemoryNode *node ;
            node = (MemoryNode*)malloc(sizeof(MemoryNode)) ;
            if(node == NULL)
            {
                printf("The memory resource is not enough ! \n") ;
                return false ;
            }
            //分配新的碎片节点
            node->head_addr = memoryNode->head_addr + memory ;
            node->tail_addr  = memoryNode->tail_addr ;
            node->memory_size = memoryNode->memory_size - memory ;

            if(preNode != NULL)
            {
                preNode->next = node ;
            }
            else
            {
                pt->head = node ;
            }
            if(memoryNode == pt->tail)
            {
                pt->tail = node ;
            }
            node->next = memoryNode->next ;
            delete memoryNode ; //清除内存空间
            return true ;
        }
        if(memoryNode->memory_size == memory)
        {
            if(memoryNode == pt->head && memoryNode == pt->tail)
            {
                pt->head = pt->tail = NULL ;
            }
            else if(memoryNode == pt->head)
            {
                pt->head = memoryNode->next ;
            }
            else if(memoryNode == pt->tail)
            {
                pt->tail = preNode ;
            }
            else
            {
                preNode->next = memoryNode->next ;
            }
            delete memoryNode ;
            return true ;
        }
        preNode = memoryNode ; //记录当前节点的前驱指针
        memoryNode = memoryNode->next ;
    }
    return false ;
}


二、最佳适应算法（Best Fit）

算法描述：

所谓“最佳”是指，每次为作业分配内存时，总是能满足要求、又是最小的空闲分区分配给作业，避免“大材小用”。为了加速寻找，该算法要求将所有的空闲分区按其容量以从小到大的顺序形成一空闲分区链。这样，第一次找到的能满足要求的空闲分区必然是最佳的。孤立的看，最佳适应算法似乎是最佳的，然而在宏观上却不一定。因为每次分配后所切割下来的剩余部分总是最小的，这样，在存储器中会留下许多难以利用的碎片。

算法实现：

/*
 *模拟最佳适应算法
 */
#include<stdio.h>
#include<malloc.h>

 typedef struct node //定义空闲分区
 {
     int head_addr , tail_addr ; //定义当前分区的起始地址
     int memory_size ; //分区大小
     struct node *next ; //指向下一个空闲分区的指针
 } MemoryNode ;

 typedef struct //定义空闲分区链表的数据结构
 {
     MemoryNode *head , *tail ; //指向分区链表的头尾指针
 } PartitionTable ;

 /*
  *初始化系统当前分区
  */
bool init_memory(PartitionTable *pt) ;

/*
 *进行当前分区链表的扫描操作
 */
void scan_memory(PartitionTable *pt) ;

/*
 *内存空间的分配函数，首次适应算法
 */
bool best_fit(PartitionTable *pt , int memory) ;

/*
 *进行分区链表的排序操作，方便起见选择冒泡
 */
void sort_mao(PartitionTable *pt) ;

/*
 *进行分区节点的插入
 */
bool insert_table(PartitionTable *pt , MemoryNode *node) ;

/*
 *进行两个节点的交换操作
 *只是进行内容的交换
 */
void swap_x(MemoryNode *m1 , MemoryNode *m2) ;

 /*
  *测试主函数
  */
int main()
{
    PartitionTable *pt ;

    int memory ;

    pt = (PartitionTable*)malloc(sizeof(PartitionTable)) ;
    if(pt == NULL)
    {
        printf("The memory is not enough ! \n") ;
        exit(0) ;
    }
    pt->head = NULL ;
    pt->tail = NULL ;

    if(! init_memory(pt))
    {
        printf("The memory deliever failed ! \n") ;
        exit(0) ;
    }

    scan_memory(pt) ;
    while(true)
    {
       printf("Please input the memory request : ") ;
        scanf("%d" , &memory) ;
        if(best_fit(pt , memory))
        {
            printf("The memory deliever success ! \n") ;
        }
        else
        {
            printf("The memory deliever failed ! \n") ;
        }
        scan_memory(pt) ;
    }
    return 0 ;
}

/*
 *初始化当前分区链表
 *对内存空间进行连续分配
 */
bool init_memory(PartitionTable *pt)
{
    //分配十个大小相等的空闲分区
    int memory_num = 10 ;

    MemoryNode *node ;

    for(int i = 0 ; i < memory_num ; i++)
    {
        node = (MemoryNode*)malloc(sizeof(MemoryNode)) ;
        if(node == NULL)
        {
          printf("The memory is not enough ! \n") ;
          return false ;
        }
        node->head_addr = i * 100 ;
        node->tail_addr = (i + 1) * 100 - 1 ;
        node->memory_size = 100 ;
        node->next = NULL ;
        if(pt->head == NULL)
        {
            pt->head = pt->tail = node ;
        }
        else
        {
            pt->tail->next = node ;
            pt->tail = node ;
        }
    }
    return true ;
}

/*
 *进行当前分区的扫描操作
 */
void scan_memory(PartitionTable *pt)
{
    if(pt == NULL || pt->head == NULL)
    {
        printf("The PartitionTable is NULL ! \n") ;
        return ;
    }
    MemoryNode *node ;
    node = pt->head ;
    printf("------分区链表---------- \n") ;
    printf("head_address   tail_address   memory_size\n") ;
    while(node)
    {
        printf("  %4d            %4d           %4d \n" , node->head_addr , node->tail_addr , node->memory_size) ;
        node = node->next ;
    }
}

/*
 *首次适应算法
 */
bool best_fit(PartitionTable *pt , int memory)
{
    MemoryNode *memoryNode , *preNode = NULL ;
    memoryNode = pt->head ;
    MemoryNode *node ;
    while(memoryNode)
    {
        if(memoryNode->memory_size > memory)
        {
            node = (MemoryNode*)malloc(sizeof(MemoryNode)) ;
            if(node == NULL)
            {
                printf("The memory resource is not enough ! \n") ;
                return false ;
            }
            //分配新的碎片节点
            node->head_addr = memoryNode->head_addr + memory ;
            node->tail_addr  = memoryNode->tail_addr ;
            node->memory_size = memoryNode->memory_size - memory ;

            if(memoryNode == pt->head && memoryNode == pt->tail)
            {
                pt->head = pt->tail = NULL ;
            }
            else if(memoryNode == pt->head)
            {
                pt->head = memoryNode->next ;
            }
            else if(memoryNode == pt->tail)
            {
                pt->tail = preNode ;
            }
            else
            {
                preNode->next = memoryNode->next ;
            }
            delete memoryNode ; //清除内存空间

            insert_table(pt , node) ;

            return true ;
        }
        if(memoryNode->memory_size == memory)
        {
            if(memoryNode == pt->head && memoryNode == pt->tail)
            {
                pt->head = pt->tail = NULL ;
            }
            else if(memoryNode == pt->head)
            {
                pt->head = memoryNode->next ;
            }
            else if(memoryNode == pt->tail)
            {
                pt->tail = preNode ;
            }
            else
            {
                preNode->next = memoryNode->next ;
            }
            delete memoryNode ;
            return true ;
        }
        preNode = memoryNode ; //记录当前节点的前驱指针
        memoryNode = memoryNode->next ;
    }
    return false ;
}

/*
 *进行两个节点的交换操作
 *只是进行内容的交换
 */
void swap_x(MemoryNode *m1 , MemoryNode *m2)
{
    int temp ;

    temp = m1->head_addr ;
    m1->head_addr = m2->head_addr ;
    m2->head_addr = temp ;

    temp = m1->tail_addr ;
    m1->tail_addr = m2->tail_addr ;
    m2->tail_addr = temp ;

    temp = m1->memory_size ;
    m1->memory_size = m2->memory_size ;
    m2->memory_size = temp ;
}

/*
 *进行分区链表的排序
 */
void sort_sort(PartitionTable *pt)
{
    MemoryNode *n1 , *n2 ;
    n1 = n2 = NULL ;
    for(n1 = pt->head ; n1 ; n1 = n1->next)
    {
        for(n2 = n1->next ; n2 ; n2 = n2->next)
        {
            if(n1->memory_size > n2->memory_size)
            {
                swap_x(n1 , n2) ;
            }
        }
    }
}

/*
 *进行分区节点的插入
 */
bool insert_table(PartitionTable *pt , MemoryNode *node)
{
    printf("The node is %d %d %d \n" , node->head_addr , node->tail_addr , node->memory_size) ;
    if(pt->head == NULL)
    {
        pt->head = pt->tail = node ;
        return true ;
    }
    MemoryNode *n , *preNode = NULL ;
    n = pt->head ;
    while(n)
    {
        if(n->memory_size > node->memory_size)
        {
            if(n == pt->head)
            {
                node->next = n ;
                pt->head = node ;
            }
            else
            {
                preNode->next = node ;
                node->next = n ;
            }
            return true ;
        }
        preNode = n ;
        n = n->next ;
    }
    pt->tail->next = node ;
    pt->tail = node ;
    return true ;
}





theBetterZ
关注
操作系统---动态分区分配算法
Swift_Jane的博客
08-22 620
可变分区分配算法中，当有新作业请求分配内存时所采用的存储分配算法有以下四种！
动态分区分配算法
热门推荐
Become hunger become strong
04-16 2万+
基于顺序搜索的动态分区分配算法1.首次适应算法(FF)：所谓的首次的意思以地址递增链接。因此在分配内存的时候，从链首开始查找，直到找到一个大小能满足要求的空闲分区为之。 2.循环首次适应算法(NF)：和首次适应算法的区别就是，在为进程分配内存空间的时候，不再是都从链首开始查找， 而是从上次找到的空闲的分区的下一个空闲分区开始查找，直到找到一个能满足要求的空闲分区。 3.最佳适应算法(BF)：将所
分区分配算法实验报告
12-16
专业老师做的 我好不容易才搞到 希望大家能看一看 好再发其他操作系统实验
分区匹配算法（操作系统）C/C++
g15827636417的博客
12-29 1057
一、首次适应算法（First Fit） 算法描述：以空闲分区为例，FF算法要求空闲分区链以地址递增的次序链接，在分配内存时，从链首开始顺序查找，直至找到一个大小能满足要求的空闲分区为止。然后再按作业的大小，从该分区中划出一块内存空间，分配给请求者，余下的空闲分区仍留在空闲链中，若从链首直至链尾都不能找到一个能满足要求的分区，则表明系统已没有足够大的内存分配给该进程，内存分配失败，返回。该算法倾向于
48.动态分区匹配算法（连续分区）
chenyson的博客
05-04 353
1.最佳匹配算法 2.最坏匹配算法 3.首次适应算法 4.循环首次适应算法
分区的动态分配
qq_35367566的博客
09-22 211
首次适应（first fit,FF)算法 该算法从空闲分区链首开始查找，直至找到一个能满足其大小要求的空闲分区为止。然后再按照作业的大小，从该分区划出一块内存分配给请求者，余下的空闲分区留在空闲分区链中。 最佳适应(best fit,BF)算法 每次为作业分配内存时，总是能把满足要求、又是最小的空闲分区分配给作业，避免“大材小用”。为了加速寻找，该算法要求将所有的空闲分区按其容量以从小到大的顺序形...
动态分区分配四种算法
06-08
最佳适应算法 最坏适应算法 首次适应算法 循环首次适应算法 VC++通过
操作系统算法多语言实现Cpp,Java, Python 包括进程调度算法、页面置换算法、动态分区匹配算法、磁盘调度算法 .zip
最新发布
05-30
页面置换算法 ava 命名: 标识符的命名力求做到统一、达意和简洁，Java请使用驼峰法命名 格式: 请确保您的代码每个缩进为4个空格，源文件使用utf-8编码，行宽不要超过120。 注释: 请确保您的类、域和方法上面有相应的...
基于多种语言实现操作系统算法_进程调度_页面置换_动态分区匹配_磁盘调度实现源码.zip
08-18
【资源说明】 1、该资源内项目代码都是经过...基于多种语言实现操作系统算法_进程调度_页面置换_动态分区匹配_磁盘调度实现源码.zip基于多种语言实现操作系统算法_进程调度_页面置换_动态分区匹配_磁盘调度实现源码.zip
操作系统的分区分配算法
11-07
1，建立分区描述器：分区描述器可根据自己编写程序的需要来建立，描述器本身所包含的内容以描述清楚内存分区情况为准, 2.建立自由主存队列：针对两种不同的放置策略（首次适应和最佳适应）来建立相应的队列结构 3，用C语言编写实现首次适应算法和最佳适应算法的程序。 4，用C语言编写回收算法。
操作系统算法多语言实现.zip
01-14
主要包括进程调度算法、页面置换算法、动态分区匹配算法、磁盘调度算法。 Java是一种高性能、跨平台的面向对象编程语言。它由Sun Microsystems（现在是Oracle Corporation）的James Gosling等人在1995年推出，被设计...
操作系统中的算法----进程调度算法，空闲分区分配算法、页面置换算法、磁盘调度算法
tangyuan_sibal的博客
04-20 956
文章目录进程调度算法空闲分区分配算法虚拟页式存储管理中的页面置换算法磁盘调度 进程调度算法 1.先进先出算法(FIFO)：按照进程进入就绪队列的先后次序来选择。即每当进入进程调度，总是把就绪队列的队首进程投入运行。 2.时间片轮转算法(RR)：分时系统的一种调度算法。轮转的基本思想是，将CPU的处理时间划分成一个个的时间片，就绪队列中的进程轮流运行一个时间片。当时间片结束时，就强迫进程让出CPU，...
推荐系统（8）：推荐算法之混合推荐
yang_shibiao的博客
05-15 3596
目录 0. 相关文章链接 1. 什么是混合推荐 2. 混合推荐+分区推荐 0. 相关文章链接 推荐系统文章汇总 1. 什么是混合推荐 推荐算法有很多种，比如基于内容的推荐、基于模型的实时推荐以及协同过滤推荐。这种组合式的应用推荐就叫组合推荐（Hybrid Recommendation）。研究和应用最多的是内容推荐和协同过滤推荐的组合。最简单的做法就是分别用基于内容的方法和协同过滤推荐方法去产生一个推荐预测结果，然后用某方法组合其结果。 2. 混合推荐+分区推荐 ...
操作系统之动态分区分配
01-20
可变分区调度算法有:最先适应分配算法,最优适应分配算法,最坏适应算法。 用户提出内存空间的申请；系统根据申请者的要求，按照一定的分配策略分析内存空间的使用情况，找出能满足请求的空闲区，分给申请者；当程序执行完毕或主动归还内存资源时，系统要收回它所占用的内存空间或它归还的部分内存空间。 每当一个进程被创建时，内存分配程序首先要查找空闲内存分区表（链），从中寻找一个合适的空闲块进行划分，并修改空闲内存分区表（链）。当进程运行完毕释放内存时，系统根据回收区的首址，从空闲区表（链）中找到相应的插入点，此时出现如下四种情况： 1) 回收区与插入点的前一个空闲分区F1相邻接，此时可将回收区直接与F1合并，并修改F1的大小； 2) 回收区与插入点的后一个空闲分区F2相邻接，此时可将回收区直接与F2合并，并用回收区的首址最为新空闲区的首址，大小为二者之和； 3) 回收区同时与插入点的前、后两个空闲分区邻接，此时需将三者合并； 4) 回收区不与任何一个空闲区邻接，此时应建一新的表项。
操作系统中文件存储空间的管理
永不言弃！
03-24 1万+
一、文件存储空间管理的概念 由于文件存储设备是分成若干个大小相等的物理块，并以块为单位来交换信息的，因此，文件存储空间的管理实质上是一个空闲块的组织和管理问题，它包括空闲块组织，空闲块的分配和空闲块的回收等几个问题。 二、文件存储空间管理的方式 1． 空闲表法（空闲文件目录） 操作系统为磁盘外存上所有空闲区建立一张空闲表，每个表项对应一个空闲区，空闲表中包含序号、空闲区的第一块
操作系统-------动态分区分配算法
Mr_Effiya的博客
11-20 2028
动态分区分配算法 1.首次适应算法（First Fit） 算法思想：将空闲分区链以地址递增的顺序连接；在进行内存分配时，从链首开始顺序查找，直到找到一块分区的大小可以满足需求时，按照该作业的大小，从该分区中分配出内存，将剩下的空闲分区仍然链在空闲分区链中。 优点：高址部分的大的空闲分区得到保留，为大作业的内存分配创造了条件； 缺点：（1）每次都是优先利用低址部分的空闲分区，造成低址部分产生大量的...
存储管理——动态分区分配算法
06-23
操作系统课设做的动态分区分配算法。第一次上传资源，做的有些乱，献丑了，其中循环首次循环和最佳、最坏分配算法其实只是从首次适应算法改了一点东西。 补充几句，是JAVA做的，分配和回收算法都有，使用数组实现
操作系统课程设计（基于空闲分区链的最佳适应算法以及进程管理器的模拟实现）
07-01
操作系统课程设计（基于空闲分区链的最佳适应算法以及进程管理器的模拟实现）
操作系统----分区适应算法
0k-ok
05-21 658
我从前最怕旁人火眼金睛，如今，倒是盼着有人能够洞幽烛远。如此，就能赠我一点欢喜。 题目： 题解： 画出作业 1、2、3 进入内存后，内存的分配情况。 0kb 20kb 100kb 116kb 256kb-1 操作系统（20kb） 作业1（80kb） 作业2（16kb） 作业3（140kb） ...
操作系统——动态分配算法（首次适应算法，最佳适应算法，最坏适应算法及回收）
weixin_43887148的博客
05-18 8796
操作系统——动态分配 写的时间早了，有些许漏洞和不足，请大家不要介意 分配方式可分为四类:单一连续分配、固定分区分配、动态分区分配以及动态可重定位分区分配算法四种方式，其中动态分区分配算法就是此实验的实验对象。动态分区分配又称为可变分区分配，它是根据进程的实际需要，动态地为之分配内存空间。在实现动态分区分配时，将涉及到分区分配中所用的数据结构、分区分配算法和分区的分配与回收操作这样三方面的问题。动态分区分配又称为可变分区分配，它是根据进程的实际需要，动态地为之分配内存空间。在实现动态分区分配时，将涉及到
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值