精华内容
下载资源
问答
  • 最优适应算法

    千次阅读 2010-05-26 21:17:00
    【问题描述】编写程序,采用最优适应算法实现可变分区存储管理方式的主存分配及回收。设计具体包括:首先构造主存空间分配表,然后完成主存空间的分配和回收;最后编写主函数对所做工作进行测试。【提示】动态构造...

     

    【问题描述】编写程序,采用最优适应算法实现可变分区存储管理方式的主存分配及回收。设计具体包括:首先构造主存空间分配表,然后完成主存空间的分配和回收;最后编写主函数对所做工作进行测试。

    【提示】动态构造主存空间分配表,包括已占分区表和空闲区表。根据申请,实施内存分配,并返回分配所得内存首址;分配完后,调整空闲区表(即扣除分配部分),并显示调整后的空闲区表;若分配失败,返回分配失败信息。回收空间时,按内存回收的四种情况从键盘接收回收区域的内存首址与大小,调整空闲区表(与前、后空闲区相连则合并再插入该项),并显示调整后的空闲区表。

     

    程序代码如下:

    //内存管理----最优适应分配算法
    #include<iostream>
    #include<string>
    #include<list>
    #include<iomanip>
    #define MemSize  1024  //定义内存大小
    #define MemBassaddr 0  //定义内存起始地址
    using namespace std;

    struct freepartion//空闲分区结构定义
    {
        int baseaddr;//空闲分区的起始地址
        int partionlen;//空闲分区的长度
    };
    struct usedpartion//已分配的内存分区结构定义
    {
        string jobname;//作业名
        int baseaddr;  //作业所占分区的起始地址
     int partionlen;//作业所占分区的长度
    };

    list<freepartion>freetable;//空闲分区表
    list<usedpartion>usedtable;//已分配分区表

    void AllocateMem(string &jobname,int &joblen)//采用最优适应分配算法为作业jobname分配joblen大小的空间
    {
     //要分配的作业名不能为已存在的作业名
     list<usedpartion>::iterator used=usedtable.begin();
     while(used!=usedtable.end())
     {
      if(used->jobname==jobname)
      {
          cout<<"作业已存在,不能再分配一个相同名的作业!"<<endl;
       return;
      }
      else
      {
          used++;
      }
     }
     //最优适应分配算法
     list<freepartion>::iterator it=freetable.begin();
     if(it==freetable.end())
     {
         cout<<"空闲分区已用完!"<<endl;
      return;
     }
        list<freepartion>::iterator itfreetmp=it;
     
        while(it!=freetable.end())
     {  
           
      if(it->partionlen>=joblen)
      {  
       if(itfreetmp->partionlen>it->partionlen)
       {
           itfreetmp=it;
        it++;
        continue;
       }
       else if(itfreetmp->partionlen<joblen)
       {
                    itfreetmp=it;
           it++;
        continue;
       }
       else
       {
          it++;
          continue;
       }
         }
      else
      {
          it++;
      }
     }//while
     if(itfreetmp->partionlen>=joblen)
     {
         //修改已分配分区表
      usedpartion tempuse;
      tempuse.baseaddr=itfreetmp->baseaddr;
      tempuse.jobname=jobname;
      tempuse.partionlen=joblen;
      usedtable.push_back(tempuse);
        
      //从空闲区分配空间
      if(itfreetmp->partionlen==joblen)
      {
       freetable.erase(itfreetmp);
      }
      else
      {
          itfreetmp->baseaddr=itfreetmp->baseaddr+joblen;
          itfreetmp->partionlen=itfreetmp->partionlen-joblen;
      }
      cout<<"为作业"<<jobname<<"分配内存成功!"<<endl;
      return;
     }
     else
     {
        cout<<"内存不足,为作业分配内存失败!"<<endl;
        return;
     }
    }
    void ReclaimMem(string jobname)//回收作业jobname所占的内存
    {  
     list<usedpartion>::iterator itused=usedtable.begin();
     list<freepartion>::iterator itfree=freetable.begin();
     freepartion free;
     while(itused!=usedtable.end())
     {
      if(itused->jobname==jobname)//找到要回收的作业
      {
       free.baseaddr=itused->baseaddr;
       free.partionlen=itused->partionlen;
       usedtable.erase(itused);
       if(itfree!=freetable.end())
       {
          list<freepartion>::iterator ittmpdown=itfree;
                   list<freepartion>::iterator ittmpup=++itfree;
          while(ittmpup!=freetable.end())
         {
          if(free.baseaddr==(ittmpdown->baseaddr+ittmpdown->partionlen))//下邻空闲区
          {
           if(free.baseaddr+free.partionlen==ittmpup->baseaddr)//下邻空闲区,上邻空闲区
           {
               ittmpdown->partionlen=ittmpdown->partionlen+free.partionlen+ittmpup->partionlen;
            freetable.erase(ittmpup);//删除上邻空闲区
            cout<<"回收作业所占的内存成功!"<<endl;
                  return;
           
                          }
           else//下邻空闲区,但不上邻空闲区
           {
               ittmpdown->partionlen=ittmpdown->partionlen+free.partionlen;
            cout<<"回收作业所占的内存成功!"<<endl;
                  return;
           
           }
          
          }
          else if(free.baseaddr+free.partionlen==ittmpup->baseaddr)//上邻空闲区,但不下邻空闲区
          {
              ittmpup->baseaddr=free.baseaddr;
           ittmpup->partionlen=free.partionlen+ittmpup->partionlen;
           cout<<"回收作业所占的内存成功!"<<endl;
              return;
         
          }
          else//既不下邻空闲区又不上邻空闲区
          {  
           if((free.baseaddr<ittmpup->baseaddr)&&(free.baseaddr>ittmpdown->baseaddr))//位于空闲区中间
           {
            freetable.insert(ittmpup,free);
            cout<<"回收作业所占的内存成功!"<<endl;
                  return;
           
           }
           else
           {
            if(free.baseaddr<ittmpdown->baseaddr)//小于空闲区下限
            {
             freetable.insert(ittmpdown,free);
             cout<<"回收作业所占的内存成功!"<<endl;
                      return;
            }
            else//大于空闲区上限
            {
                ittmpdown=ittmpup;
                      itfree++;
                                  ittmpup=itfree;
                continue;
            }
            }//
          }//else既不下邻空闲区又不上邻空闲区
                   
          }//while
          if(ittmpup==freetable.end())
         {
          if(ittmpdown->baseaddr>free.baseaddr)
          {
           if(free.baseaddr+free.partionlen==ittmpdown->baseaddr)//上邻空闲区
           {
               ittmpdown->baseaddr=free.baseaddr;
            ittmpdown->partionlen=ittmpdown->partionlen+free.partionlen;
            cout<<"回收作业所占的内存成功!"<<endl;
                  return;
           }
           else//不上邻空闲区
           {
               freetable.insert(ittmpdown,free);
            cout<<"回收作业所占的内存成功!"<<endl;
                  return;
           }
          }
          else
          {
         if(ittmpdown->baseaddr+ittmpdown->partionlen==free.baseaddr)//下邻空闲区
           {
            ittmpdown->partionlen=ittmpdown->partionlen+free.partionlen;
            cout<<"回收作业所占的内存成功!"<<endl;
                  return;
           }
           else
           {
               freetable.push_back(free);
            cout<<"回收作业所占的内存成功!"<<endl;
                  return;
           }
          }
                    
         }//if(ittmpup==freetable.end())
         /*else//没有遍历到空闲区表的末尾就已更新表
         {
             cout<<"回收作业所占的内存成功!"<<endl;
             return;
          }*/
         
       }//if(itfree!=NULL)
       else//空闲分区表为空
       {
           freetable.push_back(free);
        cout<<"回收作业所占的内存成功!"<<endl;
        return;
       }
               
      }//if(itused...)
      else //未找到要回收的作业
      {
         itused++;
      }
     }//while
       if( itused==usedtable.end())
       {
          cout<<"未找到要回收的作业,请确定所输入的作业名是否正确!"<<endl;
       }
    }

     

    //主函数
    int main()
    {
     //初始化空闲分区表
        freepartion tempfree;
     tempfree.baseaddr=MemBassaddr;
     tempfree.partionlen=MemSize;
     freetable.push_back(tempfree);
     //对内存进行管理
        int number(5);//管理操作的序号(如下所示)
     while(1)
       {
        
       if(number==5)
       {
              cout<<"内存管理操作(最优适应分配算法):"<<endl;
           cout<<"---------------------------"<<endl;
           cout<<"【0】退出程序"<<endl;
           cout<<"【1】为作业分配主存"<<endl;
           cout<<"【2】回收作业所占的主存"<<endl;
           cout<<"【3】显示空闲分区表"<<endl;
              cout<<"【4】显示已分配分区表"<<endl;
           cout<<"【5】返回管理操作界面"<<endl;
              cout<<"---------------------------"<<endl;
        }
          cout<<"请选择一个正确的管理序号操作:";
          cin>>number;
       if(cin.fail())
       {
      system("cls");
      cout<<"输入错误,请仅输入数字!"<<endl;
      cin.clear(); //清除std::cin的错误状态
            cin.sync(); //清空输入缓冲区
      continue;
       }
       string jobname;
       int joblen;
          list<freepartion>::iterator itfree=freetable.begin();
       list<usedpartion>::iterator itused=usedtable.begin();
       int i=0;//分区号从零开始
       int j=0;//已分配分区表的分区号从零开始
       switch(number)
         {
            
          case 0:exit(0);break;
             case 1:
                 cout<<"输入作业名和作业所需长度: ";
               
        cin>>jobname>>joblen;
        if(cin.fail())
              {
              cout<<"输入错误,请重新正确输入!"<<endl;
              break;
              }
                 if(joblen<-0)
        {
            cout<<"作业长度小于或等于零!"<<endl;
         break;
        }
                 AllocateMem(jobname,joblen);
                 break;
             case 2:
                 cout<<"输入要回收的作业名:";
                 cin>>jobname;
                 ReclaimMem(jobname);
                 break;
             case 3:
                 cout<<endl<<"空闲分区表状态如下:/n空闲分区号/t起始地址/t分区长度/n";
               
       
        while(itfree!=freetable.end())
                 {
         cout<<setw(5)<<i<<'/t'<<'/t'<<setw(5)<<itfree->baseaddr<<'/t'<<'/t'<<setw(5)<<itfree->partionlen<<'/t'<<endl;
                     i++;
         itfree++;
                  }
                 break;
       case 4:
                 cout<<endl<<"已分配分区表状态如下:/n作业名/t起始地址/t分区长度/n";
               
        while(itused!=usedtable.end())
                 {
         cout<<setw(5)<<itused->jobname<<'/t'<<itused->baseaddr<<'/t'<<'/t'<<itused->partionlen<<endl;
                     j++;
         itused++;
                  }
                 break;
       case 5:
        system("cls");
        break;
             default:
        cout<<"输入错误,没有这个选项"<<endl;
       
        break;
       }//swich
       cin.clear(); //清除std::cin的错误状态
          cin.sync(); //清空输入缓冲区
       }//while(1)


     return EXIT_SUCCESS;
    }


    本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/sun_top/archive/2009/12/20/5043670.aspx

    展开全文
  • 主要介绍最先适应算法、下次适应算法、最优适应算法、最坏适应算法的定义和特点,无代码实现。

    思维图

    0

    一、最先(首次)适应算法(first fit,FF

    通俗来讲就是:把进程尽量往低地址空闲区域放,放不下的话在更加地址慢慢升高。
    每一次存放,都从最低地址开始寻找满足的空闲区域,直至最高地址。即每次存放都从0开始。

    特点

    • 算法优先使用 低地址 部分空闲区,在低址空间造成许多小的空闲区,在高地址空间保留大的空闲区。
    • 选取满足申请长度要求且起始地址最小的空闲区域。
    • 空闲区域按照 起始地址 从小到大 的次序以此记录在空闲区域表中。

    优点

    • 尽量使用低地址空间,使在高地址可能形成较大的空闲区域。为以后到达的大作业分配大的内存空间创造了条件。

    缺点

    • 可能会分隔位于低地址的较大空闲区域。
    • 低址部分不断被划分,会留下许多难以利用的,很小的空闲分区,称为碎片。

    二、下次适应算法(next fit,NF

    该算法是在FF算法的基础上进行改进的,大体上与FF算法相似,而不同点就是:
    FF算法每次存储都是从0开始寻找符合要求的空闲区域;
    NF算法每次存储都是接着上次分配区域的下一个地址;

    特点

    • 该算法是对FF算法的一种改进。
    • 自上次分配空闲空间区域的下一个位置开始,选取第一个可满足的空闲区域。

    优点

    • 空闲区域分布和分配更加均匀。

    缺点

    • 可能会分隔大的空闲区域,导致以后到达的大作业无较大的空闲区域。

    三、最佳适应算法(best fit,BF

    该算法和FF算法相似,每当进程申请空间的时候,系统都是从头部开始查找。
    空闲区域是从小到大记录的,每次查找都从最小的开始,直到查找的满足要求的最小空闲区域。

    特点

    • 在分配内存空间时取满足申请要求且长度最小的空闲区域。
    • 空闲区域按照长度“由小到大”的次序以此记录于空闲区域表中。

    优点

    • 尽量不分割大的空闲区域。

    缺点

    • 可能会形成许多非常小以致以后无法使用的的空闲空间,即外部碎片。

    四、最坏适应算法(worst fit,WF

    该算法与BF算法相反,BF是用最小的空闲区域来存储东西,而WF是用最大的空闲区域来存储。

    特点

    • 在分配空间时选取满足申请要求且长度“最大”的空闲区域。
    • 空闲区域按照长度“由大到小”的次序以此记录于空闲区域表中。

    优点

    • 避免形成外部碎片

    缺点

    • 会分隔大的空闲区域,可能当遇到较长存储空间的进程时无法满足其要求。

    例题

    下图中,最左边的是内存的初始情况,现在需要将4个进程依次放入输入井中,等待系统放入内存。
    JOB1 30K
    JOB2 50K
    JOB3 20K
    JOB4 60K
    红色:已经占用的空间。
    绿色:空闲空间。
    黄色:上述4个进程占用的空间。

    02

    资料参考

    展开全文
  • 内容有优先数调度算法,时间片轮转算法,可变分区管理最先适应算法,可变分区最优适应算法
  •  //最优适应算法  public static void BestAdapt(Memory[] memory, Area[] area) {  int i, j;  for (i = 0; i ; i++) {  boolean flag = true;  int min = 0;  for (j = 0; j ; j++) {  if ...

    package oj.test;

    import java.util.*;
    import java.util.regex.Pattern;

    public class Test {

     /**
      * @param args
      */
     public static void main(String[] args) {
      Area[] area = new Area[5];
      area[0] = new Area(0, 20);
      area[1] = new Area(1, 30);
      area[2] = new Area(2, 40);
      area[3] = new Area(3, 50);
      area[4] = new Area(4, 150);
      Memory[] memory = new Memory[4];
      memory[0] = new Memory(0, 100);
      memory[1] = new Memory(1, 30);
      memory[2] = new Memory(2, 50);
      memory[3] = new Memory(3, 40);
      //FirstAdapt(memory, area);   
      BestAdapt(memory, area);   
      //BadAdapt(memory,area);
     }

      //首先适应算法
      public static void FirstAdapt(Memory[] memory, Area[] area) {
       int k;
       for (int i = 0; i < memory.length; i++) {
        k = area.length;
         for (int j = 0; j < area.length; j++) {
          if ((memory[i].getValue()) <= (area[j].getValue())) {
           area[j].setValue(area[j].getValue() - memory[i].getValue());
           System.out.println(memory[i] + "--->" + area[j]);
           break;
          }else
           k--;
          if (k < 1) {
           System.out.println(memory[i] + " Failed !");
          }
         }
       }
      }
     
      //最优适应算法
      public static void BestAdapt(Memory[] memory, Area[] area) {
       int i, j;
       for (i = 0; i < memory.length; i++) {
        boolean flag = true;
        int min = 0;
         for (j = 0; j < area.length; j++) {
          if (flag) {
           if (memory[i].getValue() <= area[j].getValue()) {
            min = area[j].getValue();
            flag = false;
           }
           } else if ((memory[i].getValue() <= area[j].getValue())&& (min >= area[j].getValue())) {
            min = area[j].getValue();
           }
         }
         if (min == 0) {
          System.out.println(memory[i] + " Failed !");
         } else {
          for (j = 0; j < area.length; j++) {
           if (area[j].getValue() == min) {
            System.out.println(memory[i] + "--->" + area[j]);
            area[j].setValue(min - memory[i].getValue());
            break;
           }
          }
         }
       }
      }

     //最坏适应算法
      public static void BadAdapt(Memory[] memory, Area[] area) {
       int i, j;
       for (i = 0; i < memory.length; i++) {
        boolean flag = true;
        int max = 0;
         for (j = 0; j < area.length; j++) {
          if (flag) {
           if (memory[i].getValue() <= area[j].getValue()) {
            max = area[j].getValue();
            flag = false;
           }
          } else if ((memory[i].getValue() <= area[j].getValue()) && (max <= area[j].getValue())) {
           max = area[j].getValue();
          }
         }
         if (max == 0) {
          System.out.println(memory[i] + " Failed !");
         } else {
          for (j = 0; j < area.length; j++) {
           if (area[j].getValue() == max) {
            System.out.println(memory[i] + "--->" + area[j]);
            area[j].setValue(max - memory[i].getValue());
            break;
           }
          }
         }
       }
      }

     private static void sop(Object o) {
       System.out.println(o);
      }
    }

    //定义一个内存作业区

    class Area {
     private int id;
     private int value;
     
     Area(int id) {
       this.id = id;
      }
     Area(int id, int value) {
      this.id = id;
      this.value = value;
     }
     public String toString() {
      return "Area:" + id;
     }
     
     public int getId() {
      return id;
     }
     public void setId(int id) {
      this.id = id;
     }
     public int getValue() {
      return value;
     }
     public void setValue(int value) {
       this.value = value;
     }

    }

    //定义一个内存作业
    class Memory {
     Area[] area = new Area[5];
     Memory[] memory = new Memory[4];
     private int id;
     private int value;
     
     public int getId() {
      return id;
     }
     public void setId(int id) {
      this.id = id;
     }
     public int getValue() {
      return value;
     }
     public void setValue(int value) {
      this.value = value;
     }
     Memory(int id) {
      this.id = id;
     }
     Memory(int id, int value) {
      this.id = id;
      this.value = value;
     }
     public String toString() {
      return "memory:" + id;
     }
    }


     

    展开全文
  • 内存管理------最优适应算法

    千次阅读 2009-12-20 16:18:00
    最优适应算法【问题描述】编写程序,采用最优适应算法实现可变分区存储管理方式的主存分配及回收。设计具体包括:首先构造主存空间分配表,然后完成主存空间的分配和回收;最后编写主函数对所做工作进行测试。【提示...

                                            最优适应算法

    【问题描述】编写程序,采用最优适应算法实现可变分区存储管理方式的主存分配及回收。设计具体包括:首先构造主存空间分配表,然后完成主存空间的分配和回收;最后编写主函数对所做工作进行测试。

    【提示】动态构造主存空间分配表,包括已占分区表和空闲区表。根据申请,实施内存分配,并返回分配所得内存首址;分配完后,调整空闲区表(即扣除分配部分),并显示调整后的空闲区表;若分配失败,返回分配失败信息。回收空间时,按内存回收的四种情况从键盘接收回收区域的内存首址与大小,调整空闲区表(与前、后空闲区相连则合并再插入该项),并显示调整后的空闲区表。

     

    程序代码如下:

    //内存管理----最优适应分配算法
    #include<iostream>
    #include<string>
    #include<list>
    #include<iomanip>
    #define MemSize  1024  //定义内存大小
    #define MemBassaddr 0  //定义内存起始地址
    using namespace std;

    struct freepartion//空闲分区结构定义
    {
        int baseaddr;//空闲分区的起始地址
        int partionlen;//空闲分区的长度
    };
    struct usedpartion//已分配的内存分区结构定义
    {
        string jobname;//作业名
        int baseaddr;  //作业所占分区的起始地址
     int partionlen;//作业所占分区的长度
    };

    list<freepartion>freetable;//空闲分区表
    list<usedpartion>usedtable;//已分配分区表

    void AllocateMem(string &jobname,int &joblen)//采用最优适应分配算法为作业jobname分配joblen大小的空间
    {
     //要分配的作业名不能为已存在的作业名
     list<usedpartion>::iterator used=usedtable.begin();
     while(used!=usedtable.end())
     {
      if(used->jobname==jobname)
      {
          cout<<"作业已存在,不能再分配一个相同名的作业!"<<endl;
       return;
      }
      else
      {
          used++;
      }
     }
     //最优适应分配算法
     list<freepartion>::iterator it=freetable.begin();
     if(it==freetable.end())
     {
         cout<<"空闲分区已用完!"<<endl;
      return;
     }
        list<freepartion>::iterator itfreetmp=it;
     
        while(it!=freetable.end())
     {  
           
      if(it->partionlen>=joblen)
      {  
       if(itfreetmp->partionlen>it->partionlen)
       {
           itfreetmp=it;
        it++;
        continue;
       }
       else if(itfreetmp->partionlen<joblen)
       {
                    itfreetmp=it;
           it++;
        continue;
       }
       else
       {
          it++;
          continue;
       }
         }
      else
      {
          it++;
      }
     }//while
     if(itfreetmp->partionlen>=joblen)
     {
         //修改已分配分区表
      usedpartion tempuse;
      tempuse.baseaddr=itfreetmp->baseaddr;
      tempuse.jobname=jobname;
      tempuse.partionlen=joblen;
      usedtable.push_back(tempuse);
        
      //从空闲区分配空间
      if(itfreetmp->partionlen==joblen)
      {
       freetable.erase(itfreetmp);
      }
      else
      {
          itfreetmp->baseaddr=itfreetmp->baseaddr+joblen;
          itfreetmp->partionlen=itfreetmp->partionlen-joblen;
      }
      cout<<"为作业"<<jobname<<"分配内存成功!"<<endl;
      return;
     }
     else
     {
        cout<<"内存不足,为作业分配内存失败!"<<endl;
        return;
     }
    }
    void ReclaimMem(string jobname)//回收作业jobname所占的内存
    {  
     list<usedpartion>::iterator itused=usedtable.begin();
     list<freepartion>::iterator itfree=freetable.begin();
     freepartion free;
     while(itused!=usedtable.end())
     {
      if(itused->jobname==jobname)//找到要回收的作业
      {
       free.baseaddr=itused->baseaddr;
       free.partionlen=itused->partionlen;
       usedtable.erase(itused);
       if(itfree!=freetable.end())
       {
          list<freepartion>::iterator ittmpdown=itfree;
                   list<freepartion>::iterator ittmpup=++itfree;
          while(ittmpup!=freetable.end())
         {
          if(free.baseaddr==(ittmpdown->baseaddr+ittmpdown->partionlen))//下邻空闲区
          {
           if(free.baseaddr+free.partionlen==ittmpup->baseaddr)//下邻空闲区,上邻空闲区
           {
               ittmpdown->partionlen=ittmpdown->partionlen+free.partionlen+ittmpup->partionlen;
            freetable.erase(ittmpup);//删除上邻空闲区
            cout<<"回收作业所占的内存成功!"<<endl;
                  return;
           
                          }
           else//下邻空闲区,但不上邻空闲区
           {
               ittmpdown->partionlen=ittmpdown->partionlen+free.partionlen;
            cout<<"回收作业所占的内存成功!"<<endl;
                  return;
           
           }
          
          }
          else if(free.baseaddr+free.partionlen==ittmpup->baseaddr)//上邻空闲区,但不下邻空闲区
          {
              ittmpup->baseaddr=free.baseaddr;
           ittmpup->partionlen=free.partionlen+ittmpup->partionlen;
           cout<<"回收作业所占的内存成功!"<<endl;
              return;
         
          }
          else//既不下邻空闲区又不上邻空闲区
          {  
           if((free.baseaddr<ittmpup->baseaddr)&&(free.baseaddr>ittmpdown->baseaddr))//位于空闲区中间
           {
            freetable.insert(ittmpup,free);
            cout<<"回收作业所占的内存成功!"<<endl;
                  return;
           
           }
           else
           {
            if(free.baseaddr<ittmpdown->baseaddr)//小于空闲区下限
            {
             freetable.insert(ittmpdown,free);
             cout<<"回收作业所占的内存成功!"<<endl;
                      return;
            }
            else//大于空闲区上限
            {
                ittmpdown=ittmpup;
                      itfree++;
                                  ittmpup=itfree;
                continue;
            }
            }//
          }//else既不下邻空闲区又不上邻空闲区
                   
          }//while
          if(ittmpup==freetable.end())
         {
          if(ittmpdown->baseaddr>free.baseaddr)
          {
           if(free.baseaddr+free.partionlen==ittmpdown->baseaddr)//上邻空闲区
           {
               ittmpdown->baseaddr=free.baseaddr;
            ittmpdown->partionlen=ittmpdown->partionlen+free.partionlen;
            cout<<"回收作业所占的内存成功!"<<endl;
                  return;
           }
           else//不上邻空闲区
           {
               freetable.insert(ittmpdown,free);
            cout<<"回收作业所占的内存成功!"<<endl;
                  return;
           }
          }
          else
          {
         if(ittmpdown->baseaddr+ittmpdown->partionlen==free.baseaddr)//下邻空闲区
           {
            ittmpdown->partionlen=ittmpdown->partionlen+free.partionlen;
            cout<<"回收作业所占的内存成功!"<<endl;
                  return;
           }
           else
           {
               freetable.push_back(free);
            cout<<"回收作业所占的内存成功!"<<endl;
                  return;
           }
          }
                    
         }//if(ittmpup==freetable.end())
         /*else//没有遍历到空闲区表的末尾就已更新表
         {
             cout<<"回收作业所占的内存成功!"<<endl;
             return;
          }*/
         
       }//if(itfree!=NULL)
       else//空闲分区表为空
       {
           freetable.push_back(free);
        cout<<"回收作业所占的内存成功!"<<endl;
        return;
       }
               
      }//if(itused...)
      else //未找到要回收的作业
      {
         itused++;
      }
     }//while
       if( itused==usedtable.end())
       {
          cout<<"未找到要回收的作业,请确定所输入的作业名是否正确!"<<endl;
       }
    }


    //主函数
    int main()
    {
     //初始化空闲分区表
        freepartion tempfree;
     tempfree.baseaddr=MemBassaddr;
     tempfree.partionlen=MemSize;
     freetable.push_back(tempfree);
     //对内存进行管理
        int number(5);//管理操作的序号(如下所示)
     while(1)
       {
        
       if(number==5)
       {
              cout<<"内存管理操作(最优适应分配算法):"<<endl;
           cout<<"---------------------------"<<endl;
           cout<<"【0】退出程序"<<endl;
           cout<<"【1】为作业分配主存"<<endl;
           cout<<"【2】回收作业所占的主存"<<endl;
           cout<<"【3】显示空闲分区表"<<endl;
              cout<<"【4】显示已分配分区表"<<endl;
           cout<<"【5】返回管理操作界面"<<endl;
              cout<<"---------------------------"<<endl;
        }
          cout<<"请选择一个正确的管理序号操作:";
          cin>>number;
       if(cin.fail())
       {
      system("cls");
      cout<<"输入错误,请仅输入数字!"<<endl;
      cin.clear(); //清除std::cin的错误状态
            cin.sync(); //清空输入缓冲区
      continue;
       }
       string jobname;
       int joblen;
          list<freepartion>::iterator itfree=freetable.begin();
       list<usedpartion>::iterator itused=usedtable.begin();
       int i=0;//分区号从零开始
       int j=0;//已分配分区表的分区号从零开始
       switch(number)
         {
            
          case 0:exit(0);break;
             case 1:
                 cout<<"输入作业名和作业所需长度: ";
               
        cin>>jobname>>joblen;
        if(cin.fail())
              {
              cout<<"输入错误,请重新正确输入!"<<endl;
              break;
              }
                 if(joblen<-0)
        {
            cout<<"作业长度小于或等于零!"<<endl;
         break;
        }
                 AllocateMem(jobname,joblen);
                 break;
             case 2:
                 cout<<"输入要回收的作业名:";
                 cin>>jobname;
                 ReclaimMem(jobname);
                 break;
             case 3:
                 cout<<endl<<"空闲分区表状态如下:/n空闲分区号/t起始地址/t分区长度/n";
               
       
        while(itfree!=freetable.end())
                 {
         cout<<setw(5)<<i<<'/t'<<'/t'<<setw(5)<<itfree->baseaddr<<'/t'<<'/t'<<setw(5)<<itfree->partionlen<<'/t'<<endl;
                     i++;
         itfree++;
                  }
                 break;
       case 4:
                 cout<<endl<<"已分配分区表状态如下:/n作业名/t起始地址/t分区长度/n";
               
        while(itused!=usedtable.end())
                 {
         cout<<setw(5)<<itused->jobname<<'/t'<<itused->baseaddr<<'/t'<<'/t'<<itused->partionlen<<endl;
                     j++;
         itused++;
                  }
                 break;
       case 5:
        system("cls");
        break;
             default:
        cout<<"输入错误,没有这个选项"<<endl;
       
        break;
       }//swich
       cin.clear(); //清除std::cin的错误状态
          cin.sync(); //清空输入缓冲区
       }//while(1)


     return EXIT_SUCCESS;
    }

     

    展开全文
  •  * 内存池分配问题(最优适应算法)  * 输入:  * 内存池大小  * 第一次分配内存的大小  * 第二次分配内存的大小  * 第三次分配内存的大小  * 释放第几次分配的内存  * 第四次分配内存大小  *  ...
  • oldSubarea->flag){//要获取最优适应分区 不重排list的话 就遍历比较了 flag = 1; if(oldSubarea->len - njob->len == 0){//刚好装得下 直接取第一个就好 tsubarea = oldSubarea; break; } if(oldSubarea->len...
  • 最优最差算法

    2013-07-20 11:30:23
    循环首次适应算法 最佳适应算法 最坏适应算法
  •  系统采用最优适应分配算法为作业分配主存空间,而且具有紧凑技术。请编程完成以下步骤(代码中OS区用“o”表示,Job1~job4用a~d表示): 输出此时的已分配区表和未分配区表; 装入 Job3(35K),输出主存分配后的...
  • 建立了异构无线Mesh网络的最优下载模型,基于这一模型,从下载时间和下载费用最小化的角度出发,提出了最优下载算法。构架了不同于传统树形图状混合的覆盖网拓扑结构,提高了算法适应性和可扩展性。在此基础上,...
  • 实验报告 班级: 计算机B191 学号: 2019537130 姓名: 陈力源 日期: 5月19日 ⒈ 实验题目 主存储器空间分配实验。...能分别使用首次适应算法...通过首次适应算法、最佳适应算法和最坏适应算法实现主存空间的...
  • 一种新型的,基于遗传算法的神经网络特征离散化方法也被提出,认为遗传算法可通过搜索最优或接近最优的参数来获得最优适应函数,因此GAFD可以找到最优或者接近最优的离散阈值,从而提高了最终网络的通用性和模型的...
  • 分析了自适应光学系统的波前斜率校正效果,综合大气湍流扰动和测量噪声的统计特性,在最小二乘复原算法的基础上推导得出一种形式简洁、易于实际操作的最优斜率复原算法。在大气湍流波前扰动条件下,对这种最优斜率复原...
  • void allocate(char j,float xk)//采用最优分配法分配xk大小的空间 { int i,k,p,c;  float ad;  k=-1;  i=point.fhead;  c=i;  do  { if(freetable[i].length >=xk && freetable[i].flag=="可用")  if(k==-...
  • 对GPS/SINS组合导航的工作原理和模型建立进行详细的分析,设置了两个传感器。...合的导航参数最优估计滤波方法。通过计算机仿真说明该方法可提高导航系统的计算精度和速度,有较好的容错性和 环境适应性,具有实际使用价值
  • //最优适应算法  public static void BestAdapt(Memory[] memory, Area[] area) {  int i, j;  for (i = 0; i ; i++) {  boolean flag = true;  int min = 0;  for (j = 0; j ; j++) {  if (flag) {  ...
  • 以前写了他的算法描述,这次把他的窗口程序一块写了出来,用 java 写的,感觉还不是那么的完美,但已经能够说明问题了,达到了演示的目的。import javax.swing.*;import java.awt.event.*;import javax.swing.border...
  • 一实验目的 通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解熟悉可变分区存 储管理的内存分配和回收 二实验内容 确定内存空间分配表 采用最优适应算法完成内存空间的分配和回收 编写主函数对所做工作...
  • 2.采用最优适应算法完成内存空间的分配和回收;3.编写主函数对所做工作进行测试。三.实验背景材料由于可变分区的大小是由作业需求量决定的,故分区的长度是预先不固定的,且分区的个数也随内存分配和回收变动。...
  • MAT之PSO:利用PSO算法优化二元函数,寻找最优个体适应度 目录 实现结果 设计代码 实现结果 设计代码 figure [x,y] = meshgrid(-5:0.1:5,-5:0.1:5); z = x.^2 + y.^2 - 10*cos(2*pi*x) - 10*...
  • 遗传算法最优保留

    2013-02-25 17:22:29
    遗传算法 GA 最优保留 轮盘赌算子、单点交叉算子、位点变异算子 最后绘制最优适应度进化曲线
  • 提出一种模糊复合最优粒子群优化(FHMPSO)算法,并将该算法应用于永磁同步电机控制系统PI调速器参数整定与优化中。优化算法适应度函数采用永磁同步电机转速偏差ITAE指标,采用永磁同步电机矢量控制系统模型对原始PSO,...
  • 考虑到个体的有限通信与感知能力,传统集中式求解算法无法适应实际需求,提出一种基于分布式交替映射凸优化的分布式时间最优编队构型形成算法,使得个体间仅依赖局部通信与局部计算实现编队构型的快速形成;将该问题建模...
  • title('PSO:利用粒子群算法实现对目标函数寻找最优个体适应度—Jason niu','fontsize',12); xlabel('进化代数','fontsize',12);ylabel('适应度','fontsize',12);   转载于:...
  • GBSO:全局最优头脑风暴优化算法 参考文献 《Global-best brain storm optimization algorithm》 要点 提议引入一个全局最优,结合每次变量更新和基于适应度的分组来提高BSO的性能。此外,该算法还引入了一种由...
  • 内存分配算法

    2011-11-29 16:43:42
    内存分配算法: 最先适应算法,最优适应算法,最坏适应算法 mfc实现,dc作图形象化
  • 首次适应算法(First Fit):该算法从空闲分区链首开始查找,直至找到一个能满足其大小要求的空闲分区为止。然后再按照作业的大小,从该分区中划出一块内存分配给请求者,余下的空闲分区仍留在空闲分区链中。 最佳...
  • 针对以上问题进行了研究,提出了一种基于最优人工蜂群算法与支持向量机相结合的P2P流量识别方法。利用人工蜂群算法,将SVM的参数和特征选择问题视为最优化问题同步处理,可以获得整体性能最优的参数和特征子集。在...
  • 在分析时间最优控制问题已有求解方法优缺点的基础上,提出基于混合遗传算法求解时间最优控制问题的直接方法,为了利用该算法求解时间最优控制问题,将约束作为惩罚项包括在目标函数中,以此构造适应度函数。对线性阻尼...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 725
精华内容 290
关键字:

最优适应算法