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

最新推荐文章于 2020-05-04 10:53:50 发布
最新推荐文章于 2020-05-04 10:53:50 发布
阅读量1k 收藏 4
点赞数
分类专栏： 计算机操作系统 文章标签： 内存分配 算法 内存 计算机操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/g15827636417/article/details/53927461
版权

一、首次适应算法（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 ;
}
luo___ye
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
特征点匹配——ORB算法介绍
lhanchao的博客
09-22 4万+
《ORB: an efficient alternative to SIFT or SURF》是Rublee等人在2011年的ICCV上发表的一篇有关于特征点提取和匹配的论文，这篇论文介绍的方法跳出了SIFT和SURF算法的专利框架，同时以极快的运行速度赢得了众多青睐。下面我简单介绍一下ORB算法的流程。ORB算法的主要贡献如下： （1）为FAST算法提取的特征点加上了一个特征点方向； （2）使
分区分配算法（Partitioning Placement Algorithm）
夏沫的杂物间
05-16 3283
写在前面： 本文章旨在总结备份、方便以后查询，由于是个人总结，如有不对，欢迎指正；另外，内容大部分来自网络、书籍、和各类手册，如若侵权请告知，马上删帖致歉。 来源： https://blog.csdn.net/u011070169/article/details/53177987 https://www.gatevidyalay.com/contiguous-memory-allocation-practice-problems/ 首次适应算法（first-fit）：从空闲分区表的第一个表目起.
分区分配算法
入门C语言——杭电oj2016
11-20 4191
分区分配算法 1.首次适应算法FF(First Fit) 基本思想：要求空闲分区按地址递增的次序排列。当进行内存分配时，从空闲区表头开始顺序查找，直到找到第一个能满足其大小要求的空闲区为止。分一块给请求者，余下部分仍留在空闲区中。 2.最佳适应算法BF（Best Fit） 基本思想：BF的空闲分区表（或空闲分区链）按空闲区大小的升序方法组织。分配时，按空闲分区表（或空闲分区链）的先后次序，从头查找...
48.动态分区匹配算法（连续分区）
chenyson的博客
05-04 332
1.最佳匹配算法 2.最坏匹配算法 3.首次适应算法 4.循环首次适应算法
操作系统分区分配C++版
12-20
在这个C++实现的操作系统课程实验中，我们将关注的是一个重要的概念——分区分配。分区分配是操作系统内存管理的一部分，它涉及到如何有效地在主存中为多个并发运行的进程分配空间。 在传统的操作系统设计中，内存...
动态分区分配算法
02-27
在计算机操作系统中，内存管理是核心功能之一，而动态分区分配算法则是内存管理中的关键技术。动态分区分配算法旨在高效地分配和回收内存空间，以满足不同进程对内存的需求。根据给定的代码示例，我们可以深入探讨四...
c/c++经典面试题
10-28
根据给定文件的信息，我们可以提炼出以下几个C/C++面试题中的关键知识点： ### 1. `sizeof` 运算符及内存对齐规则 #### 题目描述 理解 `sizeof` 运算符的基本用法及其在结构体内存对齐上的应用。 #### 解析 - **...
操作系统分配内存过程模拟器
01-10
操作系统会根据最先匹配算法找到合适的内存块，更新内存分配表，并修改相应的内存状态。 5. **内存回收**：当进程结束或释放内存时，模拟器将执行内存回收，这包括标记内存块为可用，并可能涉及到内存合并以减少...
c++算法大全.docx
05-08
- KMP算法：不回溯的模式匹配算法，避免冗余比较。 - Rabin-Karp算法：使用哈希函数进行字符串匹配，减少比较次数。 - Boyer-Moore算法：根据模式串的特性进行滑动窗口匹配，提高查找效率。 6. **数据结构** - ...
二分图匹配算法（C++实现）
03-10
基于二分图的常用算法 最大匹配——匈牙利算法 最佳匹配——KM算法 感谢原作者
动态分区分配四种算法
06-08
最佳适应算法 最坏适应算法 首次适应算法 循环首次适应算法 VC++通过
固定分区最佳适应算法C++实现
03-29
操作系统课程设计，采用固定分区，用最佳适应算法实现管理内存分配与回收
基于顺序搜索的动态分区算法
码的世界
10-11 2054
首次适应算法（first fit ，ff） 要求 空闲链递增的方式链接 工作方式 从链首开始查找，直到找到一个大小能满足要求的空闲分区为止 特点 优先利用内存中低地址部分 高地址空闲区大，可以给大程序使用 低地址不断被分割，形成碎片 每次从低地址查找，开销大 循环首次适应算法（next fit，nf） 解决问题 为了解决 ff 算法的缺点 特点 从上一次找到的空闲分区的下一个空闲分区开始查找...
作业调度和空闲分区分配算法
菜鸟哆哆的专栏
01-10 5040
本文中红色字体为自创算法，未经验证，如果不可行，希望不吝赐教！ 一、常见的批处理作业调度算法： 1.先来先服务调度算法（FCFO）： 1.算法总结：按照各个作业进入到系统的的自然顺序来调度作业，首先到来的作业排在前面，也是最先被执行的，后续的作业被逐次被执行,该算法即可用于作业调度，也可以用于进程调度，使之运行直到完成或者因为发生某件事阻塞而放弃处理机。 2.算法分析：该算法的硬件实现和软...
如何判断操作系统所在磁盘
Thinking -Walking@未名
01-23 1946
1：首先找到系统所在分区 ，使用函数为 UINT GetWindowsDirectory(  LPTSTR lpBuffer,  // address of buffer for Windows directory  UINT uSize        // size of directory buffer);获取哪一个分区是系统分区。2：根据分区获取该分区对应的物理磁盘 
连续分配方式 --（单一连续/固定分区）
热门推荐
dongyanxia1000的专栏
06-15 1万+
1、连续分配方式 连续分配方式：为一个用户程序分配一个连续的内存空间。 连续分配方式进一步分为：单一连续分配、固定分区分配、动态分区分配以及动态重定位分区分配。 2、单一连续分配 最简单的一种存储管理方式，但只能用于单用户、单任务的操作系统中。 采用这种存储管理方式时，可把内存分为系统区和用户区两部分，系统区仅提供给OS使用，通常是放在内存的低址部分； 用户区是指除系统区以外的全部内存
从头开始编写操作系统：C/C++实现指南
从头开始写操作系统 本资源提供了一个详细的指南，用于从头开始编写操作系统。该指南涵盖了操作系统的所有方面，从设置开发环境到实现操作系统的各个组件。下面是该资源中的一些关键知识点： 1. x86架构介绍：该...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值