Ubuntu22.2下C语言编程实现,首次,最佳适应算法

参考目录:

  • 1.题目要求
  • 2.分析设计
  • 3.程序代码
  • 4.运行截图
  • 5.程序说明

1.题目要求

编写C语言程序,模拟实现首次/最佳/最坏适应算法(选择其中之一即可)的内存块分配和回收,要求每次分配和回收后显示出空闲分区和已分配分区的情况。假设初始状态下,可用的内存空间为640KB。
假设下列作业请求序列:
(1)作业1 申请130 KB (2)作业2 申请60 KB (3)作业3 申请100 KB
(4)作业2 释放60 KB (5)作业3 释放100 KB (6)作业1 释放130 KB
显示每次作业申请或释放后当前内存情况。

2.分析设计

根据题目,分析设计如下:
(1)程序初始需要提供用户选择方式。选择首次适应算法,还是最佳是适应算法,选择作业的回收,作业的展示,程序的退出能。
(2)当用户选择首次适应算法或者最佳适应算法,需要用户输入分配内存的大小。在输入大小时在根据算法的设计进行分配。
(3)当内存分配过后,如果分配成功就需要提示成功,如果失败则需要提示失败。
(4)内存回收需要用户输入回收作业的ID,根据作业的ID对内存进行回收。在回收时要分多种情况进行判断。
(5)作业展示,需要向用户展示,作业的ID,起始地址,内存大小,状态是已分配还是空闲。
(6)一个作业需要用到数据结构中的双向列表,用一个双向列表来表示节点。

3.程序代码

#include 
#include 

struct area
{
  int id;             // 编号
  int addr_front;     //首地址
  int addr_end;      //结束地址
  int size;           //分区大小
  int flag;           //分配标志,0表示空闲,1表示占用
  struct area *front; //上一分区
  struct area *next;  //下一分区
};

typedef struct area partion;

partion *head = NULL; //分区队列头节点
int need;             //需求
int choice = 1;       //操作选项

partion *createPartion(int id, int addr_front, int size, int flag); //生成一个节点
void inputNeed();                                                   //输入需求量
void assign(partion *ptr, int need);                                //分配分区
void first_fit();                                                   //首次适应算法
void best_fit();                                                    //最佳适应算法
void showMemoryInfo();                                              //打印分区分配状况
void recovery();                                                    //分区回收
void changeIdValue(partion *ptr, int delta);                        //改变从ptr开始所有节点的id值

int main(void)
{
  head = createPartion(0, 0, 640, 0);
  while (choice != 0)
  {
    puts("-------------------\n请选择操作:\n1:首次适应;\n2:最佳适应;\n3:内存回收;\n4:展示详细信息;\n0:推出......\n-------------------");
    scanf("%d", &choice);
    switch (choice)
    {
    case 1:
      inputNeed();
      first_fit();
      break;
    case 2:
      inputNeed();
      best_fit();
      break;
    case 3:
      recovery();
      showMemoryInfo();
      break;
    case 4:
      showMemoryInfo();
      break;
    case 0:
      puts("byebye");
      break;
    default:
      break;
    }
  }

  return 0;
}

//创建一个节点
partion *createPartion(int id, int addr_front, int size, int flag)
{
  partion *p = (partion *)malloc(sizeof(partion));
  p->id = id;
  p->addr_front = addr_front;
  p->addr_end=addr_front+size-1;
  p->size = size;
  p->flag = flag;
  p->front = NULL;
  p->next = NULL;
  return p;
}

void inputNeed()
{
  printf("请输入需要的内存大小:");
  scanf("%d", &need);
}

void first_fit()
{
  partion *fit = NULL;
  partion *ptr = head;
  while (ptr != NULL)
  {
    if (ptr->size >= need && ptr->flag == 0)//如果是空闲并且大小大于则给予分配
    {
      fit = ptr;
      break;
    }
    ptr = ptr->next;
  }
  if (fit != NULL)
  {
    assign(fit, need);
    printf("内存分配成功,分配如下:\n");
    showMemoryInfo();
  }
  else
  {
    puts("抱歉,内存分配失败!");
    free(fit);
  }
}

void best_fit()
{
  partion *fit = NULL;
  partion *ptr = head;
  int flag = 0; //flag 表示是否找到可分配的分区
  while (ptr != NULL)
  {
    if (ptr->flag == 0 && ptr->size >= need)
    {
      if (flag == 0)
      {
        //只有遇到的第一个可分配分区会执行此操作
        fit = ptr;
        flag = 1;
      }
      else
      {
        //若遇到可分配且分区更小即更适合的则更新
        if (ptr->size < fit->size)
        {
          fit = ptr;
        }
      }
    }
    ptr = ptr->next;
  }
  //先处理没找到合适分区的情况
  if (flag == 0)
  {
    puts("抱歉,未找到合适的分区!");
    free(fit);
    return;
  }
  //找到则分配
  assign(fit, need);
  puts("内存分配成功,分配如下:\n!");
  showMemoryInfo();
}

void showMemoryInfo()
{
  partion *ptr = head;
  puts("\n\n---------------------------------------------");
  puts("总内存分配情况如下:");
  puts("---------------------------------------------");
  puts("序号ID****开始地址****结束地址****内存大小****状态****");
  while (ptr != NULL)
  {
    printf("%-12d%-12d%-12d%-12d",ptr->id,ptr->addr_front,ptr->addr_end,ptr->size);
   // printf("序号id:%21d%10c\n开始地址:%10d%10c\n", ptr->id, '|', ptr->addr_front, '|');
    //printf("结束地址:%10d%10c\n", ptr->addr_end, '|');
    //printf("内存大小:%11d%10c\n", ptr->size, '|');
    printf("%-12s\n", ptr->flag == 0 ? "空闲" : "已分配");
    puts("-----------------------------------------------------");
    ptr = ptr->next;
  }
  puts("---------------------------------------------\n\n");
}

void assign(partion *ptr, int need)
{

  if (need == ptr->size)//空闲的空间恰好等同需要的空间
  {
    ptr->flag = 1;
    return;
  }
  //空闲的空间大于需要的空间
  partion *assigned = createPartion(ptr->id, ptr->addr_front, need, 1);
  assigned->next = ptr;
  assigned->front = ptr->front;
  changeIdValue(ptr, 1);//把后面的节点的id值都增加1
  ptr->addr_front += need;
  ptr->size -= need;
  if (ptr->front != NULL)//空闲区的头不空,就在前一个节点后面添加分配的节点
  {
    ptr->front->next = assigned;
  }
  else//空闲节点前没有节点
  {
    head = assigned;
  }

  ptr->front = assigned;//空闲节点的头指向新分配的
}

void recovery()
{
  printf("请输入需要回收作业的ID号:");
  int id, flag = 0;
  scanf("%d", &id);
  partion *ptr = head;
  while (ptr != NULL)
  {
    if (id == ptr->id)
    {
      flag = 1;
      break;
    }
    ptr = ptr->next;
  }
  if (flag == 0)
  {
    puts("没有找到你需要回收的作业!");
    return;
  }
  if (ptr->flag == 0)
  {
    puts("该ID已经是空闲的了");
    return;
  }
  if (ptr->front == NULL)
  {
    //第一个分区

    if (ptr->next == NULL || ptr->next->flag == 1)
    {
      //后面不空或后面没有
      ptr->flag = 0;
      return;
    }
    if (ptr->next->flag == 0)
    {
      //后面空
      ptr->size += ptr->next->size;
      ptr->flag = 0;//标记为空闲
      if (ptr->next->next != NULL)//把下一个节点的头指向该节点
      {
        ptr->next->next->front = ptr;
      }
      ptr->next = ptr->next->next;//合并两个节点

      free(ptr->next);//真实释放节点
      return;
    }
  }
  if (ptr->next == NULL)
  {
    //最后一个分区
    if (ptr->front == NULL || ptr->front->flag == 1)
    {
      //前面不空或者前没有
      ptr->flag = 0;
      return;
    }
    if (ptr->front->flag == 0)
    {
      //前面为空
      ptr->front->size += ptr->size;
      ptr->front->next = NULL;
      free(ptr);
      return;
    }
  }
  if (ptr->front->flag == 0 && ptr->next->flag == 0)
  {
    //上下都空
    ptr->front->size += ptr->size + ptr->next->size;
    ptr->front->next = ptr->next->next;
    if (ptr->next->next != NULL)
    {
      ptr->next->next->front = ptr->front;
    }
    changeIdValue(ptr->front->next, -2); //更改id
    free(ptr->next);
    free(ptr);
    return;
  }
  if (ptr->front->flag == 0 && ptr->next->flag == 1)
  {
    //上空下不空
    ptr->front->size += ptr->size;
    ptr->front->next = ptr->next;
    ptr->next->front = ptr->front;
    changeIdValue(ptr->front->next, -1);
    free(ptr);
    return;
  }
  if (ptr->front->flag == 1 && ptr->next->flag == 0)
  {
    //上不空下空
    ptr->size += ptr->next->size;
    if (ptr->next->next != NULL)
    {
      ptr->next->next->front = ptr;
    }
    partion *p_next = ptr->next;  //保存一下下方为空的那个分区,以便一会释放 
    ptr->next = ptr->next->next;
    ptr->flag = 0;
    changeIdValue(ptr->next, -1);
    free(p_next);
    return;
  }
  if (ptr->front->flag == 1 && ptr->next->flag == 1)
  {
    //上下都不空
    ptr->flag = 0;
    return;
  }  
}

void changeIdValue(partion *ptr, int delta)
{
  while (ptr != NULL)
  {
    ptr->id += delta;
    ptr = ptr->next;
  }
}

4.运行截图

首次适应算法
开始

(1)作业1 申请130 KB

(2)作业2 申请60 KB

(3)作业3 申请100 KB

(4)作业2 释放60 KB

(5)作业3 释放100 KB

(6)作业1 释放130 KB

最佳适应算法
开始:

(1)作业1 申请130 KB

(2)作业2 申请60 KB

(3)作业3 申请100 KB

(4)作业2 释放60 KB

(5)作业3 释放100 KB

(6)作业1 释放130 KB

5.程序说明

总流程图:

总流程图是提供程序开始运行的界面图,供用户选择,其中用户可以选择的选项有,首次适应算法,最佳适应算法,内存回收,内存作业的显示。每选择一个功能就执行相应的函数代码。

首次适应算法流程图:

首次适应算法,首先用户输入作业需要的内存大小,然后程序从低地址向高地址寻找空间空间,如果找到空闲空间,如果空闲空间的大小比作业需要的空间大则进行分配,如果空闲空间比作业需要的空间小,则继续寻找下一个空闲空间。如果所有的空闲空间都寻找完也没有符合要求的,那么作业的内存分配失败。

最佳适应算法流程图

最佳适应算法,首页用户输入作业需要的内存空间,程序从低地址开始寻找空闲空间,如果第一次找合适的空间分配,就临时存储这个空间地址,继续向下继续寻找符合的地址空间,如果寻找到合适的空间空间范围,且新的空间大小比临时存储的空间大小还小,则新的符合空间更新为临时符合空间,依次类推到最后。如果程序没有临时最佳的地址空间,则并没有分配到内存,所以作业内存分配失败。如果有临时最佳空间地址,则把最佳的地址空间分配给作业。

内存回收流程图:

作业回收,首先需要需要输入回收作业的ID,先判断作业ID是否存在,存在才能进行释放,在ID存在的前提下判断,该ID的作业状态,只有为已分配状态猜才进行释放。释放则的分情况讨论。释放的节点分为头部,中间,尾部。如果释放的节点前后已经有空闲空间,就需要进行合并。

你可能感兴趣的:(算法(含蓝桥杯),算法,c语言,c++,ubuntu,数据结构)