精华内容
下载资源
问答
  • 动态分区分配算法

    2018-06-22 18:52:49
    《计算机与操作系统(第四版)》动态分区分配算法 1.首次适应算法(first fit) 2.循环首次适应算法(next fit) 3.最佳适应算法(best fit)
  • 动态分区分配算法.cpp

    2020-09-11 21:08:54
    设计程序模拟四种动态分区分配算法:首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。假设内存中空闲分区个数为n,空闲分区大小分别为P1, … ,Pn,在动态分区分配过程中需要分配的进程个数...
  • 操作系统课设做的动态分区分配算法。第一次上传资源,做的有些乱,献丑了,其中循环首次循环和最佳、最坏分配算法其实只是从首次适应算法改了一点东西。 补充几句,是JAVA做的,分配和回收算法都有,使用数组实现
  • 湖南文理学院实验报告课程名称操作系统课程设计实验名称存储管理——动态分区分配算法的模拟成绩学生姓名曹乐专业计算机班级、学号 13101 18同组者姓名实验日期 12.211、实验目的通过这次实验,加深对动态分区分配...

    湖南文理学院实验报告

    课程名称操作系统课程设计

    实验名称存储管理——动态分区分配算法的模拟

    成绩

    学生姓名曹乐专业计算机

    班级、学号 13101 18

    同组者姓名

    实验日期 12.21

    1、实验目的

    通过这次实验,加深对动态分区分配算法的理解,进一步掌握首次适应算法、循环首次适应算法、最佳适应算法、最坏适应算法和快速适应算法的实现方法。

    2、试验内容

    问题描述:

    设计程序模拟四种动态分区分配算法:首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。假设内存中空闲分区个数为n,空闲分区大小分别为P1, … ,P n,在动态分区分配过程中需要分配的进程个数为m(m≤n),它们需要的分区大小分别为S1, … ,S m,分别利用四种动态分区分配算法将m个进程放入n个空闲分区,给出进程在空闲分区中的分配情况。

    3、程序要求:

    1)利用首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法四种动态分区分配算法模拟分区分配过程。

    展开全文
  • 操作系统 动态分区分配算法课程设计 java版湖 南 文 理 学 院 实 验 报 告课程名称 操作系统课程设计实验名称 存储管理——动态分区分配算法的模拟成绩学生姓名 曹乐 专业 计算机班级、学号 13101 18同组者姓名实验...

    操作系统 动态分区分配算法课程设计 java版

    湖 南 文 理 学 院 实 验 报 告

    课程名称 操作系统课程设计

    实验名称 存储管理——动态分区分配算法的模拟

    成绩

    学生姓名 曹乐 专业 计算机

    班级、学号 13101 18

    同组者姓名

    实验日期 12.21

    1、实验目的

    通过这次实验,加深对动态分区分配算法的理解,进一步掌握首

    次适应算法、循环首次适应算法、最佳适应算法、最坏适应算法

    和快速适应算法的实现方法。

    2、试验内容

    问题描述:

    设计程序模拟四种动态分区分配算法:首次适应算法、循环首次

    适应算法、最佳适应算法和最坏适应算法的工作过程。假设内存

    n P , …,P

    中空闲分区个数为 ,空闲分区大小分别为 1 n,在动态分

    m m≤n

    区分配过程中需要分配的进程个数为 ( ),它们需要的分区

    S , …,S m

    大小分别为 1 m,分别利用四种动态分区分配算法将 个进

    n

    程放入 个空闲分区,给出进程在空闲分区中的分配情况。

    3、程序要求:

    1)利用首次适应算法、循环首次适应算法、最佳适应算法和最坏

    适应算法四种动态分区分配算法模拟分区分配过程。

    2)模拟四种算法的分区分配过程,给出每种算法进程在空闲分区

    中的分配情况。

    3 n P , …,P m

    )输入:空闲分区个数 ,空闲分区大小 1 n,进程个数 ,

    S , …,S 1- 2-

    进程需要的分区大小 1 m,算法选择 首次适应算法, 循

    3- 4- 5-

    环首次适应算法, 最佳适应算法, 最坏适应算法, 快速适应

    算法。

    4、需求分析

    (1) 输入的形式和输入值的范围

    算法选择

    空闲分区个数

    空闲分区大小(KB)

    作业个数

    作业名称

    作业大小(KB)

    (2) 输出的形式

    最终内存空闲分区的分配情况

    5、调试分析

    通过这次课程设计我练习了用JAVA写系统软件,对OS中可变分区

    存储管理有了更深刻的了解。在写程序的时候也遇到了一些困难。比

    如在设计数据结构时特别犹豫,总想找一个很合适的。但是,后来才

    知道,关键要多尝试,而空想是没有用的。最后我证实了自己的设计

    的合理性。还有为了使程序更健壮,我尝试着将程序中的输入部分全

    部改为字符 (串)。很遗憾的是因为时间问题,没有把这个模拟程序

    写成动画形式,还可以加几句代码后实现动态的增加作业。通过本次

    实验,深入理解了动态分区分配算法的思想,培养了自己的动手能力,

    通过实践加深了记忆。

    6、测试结果

    (1)首次适应算法

    (2)循环首次适应算法

    (3)最佳适应算法

    (4)最坏适应算法:

    (5)快速适应算法:

    7、附录(java)

    package experiment;

    import java.io.BufferedInputStream;

    import java.io.FileInputStream;

    import java.io.FileNotFoundException;

    import java.util.Scanner;

    public class D_ProcessPartition {

    private static

    展开全文
  • 2016 新编操作系统实验四报告 - 动态分区分配算法 操作系统实验报告 实验四 动态分区分配算法 学号: 班级: 姓名: 实验目的 通过这次实验加深对动态分区分配算法的理解进一步掌握首次适应算法 循环首次适应算法最佳...
  • 湖 南 文 理 学 院 实 验 报 告课程名称 操作系统课程设计实验名称 存储管理——动态分区分配算法的模拟成绩学生姓名 曹乐 专业 计算机班级、学号 13101 18同组者姓名实验日期 12.21实验目的通过这次实验,加深对...

    湖 南 文 理 学 院 实 验 报 告

    课程名称 操作系统课程设计

    实验名称 存储管理——动态分区分配算法的模拟

    成绩

    学生姓名 曹乐 专业 计算机

    班级、学号 13101 18

    同组者姓名

    实验日期 12.21

    实验目的

    通过这次实验,加深对动态分区分配算法的理解,进一步掌握首次适应算法、循环首次适应算法、最佳适应算法、最坏适应算法和快速适应算法的实现方法。

    试验内容

    问题描述:

    设计程序模拟四种动态分区分配算法:首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。假设内存中空闲分区个数为n,空闲分区大小分别为P1, … ,Pn,在动态分区分配过程中需要分配的进程个数为m(m≤n),它们需要的分区大小分别为S1, … ,Sm,分别利用四种动态分区分配算法将m个进程放入n个空闲分区,给出进程在空闲分区中的分配情况。

    程序要求:

    1)利用首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法四种动态分区分配算法模拟分区分配过程。

    2)模拟四种算法的分区分配过程,给出每种算法进程在空闲分区中的分配情况。

    3)输入:空闲分区个数n,空闲分区大小P1, … ,Pn,进程个数m,进程需要的分区大小S1, … ,Sm,算法选择1-首次适应算法,2-循环首次适应算法,3-最佳适应算法,4-最坏适应算法,5-快速适应算法。

    需求分析

    (1) 输入的形式和输入值的范围

    算法选择

    空闲分区个数

    空闲分区大小(KB)

    作业个数

    作业名称

    作业大小(KB)

    (2) 输出的形式

    最终内存空闲分区的分配情况

    调试分析

    通过这次课程设计我练习了用JAVA写系统软件,对OS中可变分区存储管理有了更深刻的了解。在写程序的时候也遇到了一些困难。比如在设计数据结构时特别犹豫,总想找一个很合适的。但是,后来才知道,关键要多尝试,而空想是没有用的。最后我证实了自己的设计的合理性。还有为了使程序更健壮,我尝试着将程序中的输入部分全部改为字符(串)。很遗憾的是因为时间问题,没有把这个模拟程序写成动画形式,还可以加几句代码后实现动态的增加作业。通过本次实验,深入理解了动态分区分配算法的思想,培养了自己的动手能力,通过实践加深了记忆。

    测试结果

    (1)首次适应算法

    (2)循环首次适应算法

    (3)最佳适应算法

    (4)最坏适应算法:

    (5)快速适应算法:

    附录(java)

    package experiment;

    import java.io.BufferedInputStream;

    import java.io.FileInputStream;

    import java.io.FileNotFoundException;

    import java.util.Scanner;

    public class D_ProcessPartition {

    private static int MaxNum = 100;

    //空闲分区个数

    private static int n;

    //作业个数

    private static int m;

    //空闲分区大小

    private static int FreePartition[] = new int[MaxNum];

    //作业名称

    private static char ProcessName[] = new char[MaxNum];

    //作业需求空间大小

    private static int ProcessNeed[] = new int[MaxNum];

    //作业分配标志

    private static boolean state[] = new boolean[MaxNum];

    //空闲分区个数

    private static int PartitionNum;

    //作业个数

    private static int ProcessNum;

    //?????

    private static char order[][] = new char[MaxNum][MaxNum];

    //?????

    private static char ch[] = new char[MaxNum];

    //临时变量

    private static int temp;

    //算法选择

    //1-首次适应算法

    //2-循环首次适应算法

    //3-最佳适应算法

    //4-

    展开全文
  • 存储管理动态分区分配算法的模拟 一(题目: 存储管理 --- 动态分区分配算法的模拟 二(任务: 设计主界面以灵活选择某算法且以下算法都要实现 :首次适应算 法循环首次适应算法最佳适应算法 ; 三(思想: 对任务进行构思和...
  • 操作系统实验报告 实验2 动态分区分配算法 报告日期2016-6-15 姓 名 学 号 班 级 任课教师 实验2 动态分区分配算法 一实验内容 编写一个内存动态分区分配模拟程序模拟内存的分配和回收的完整过程 二实验目的 一个好...
  • 操作系统的动态分区分配算法(控制台程序),供学习使用。
  • 操作系统的课程设计报告...用C语言编写的程序,实现了可重定向动态分区分配算法,选取首次适应算法,实现紧凑功能,用单链表模拟内存状态。因为网上几乎没有紧凑功能的代码,所以自己写了,希望造福人类。可能有些小bug
  • 操作系统动态分区分配算法实现,运行成功,另外带有文档
  • 操作系统:动态分区分配算法

    千次阅读 多人点赞 2018-12-11 10:15:27
     动态分区分配算法 一:概念  动态分区分配是根据进程的实际需要,动态地为之分配内存空间。在实现可变分区分配时,将涉及到分区分配中所用的数据结构、分区分配算法和分区的分配与回收操作这样三个问题。    ...

    目的:陆续整理近一年的学习收获

                                                           动态分区分配算法

    一:概念 

    • 动态分区分配是根据进程的实际需要,动态地为之分配内存空间。在实现可变分区分配时,将涉及到分区分配中所用的数据结构、分区分配算法和分区的分配与回收操作这样三个问题。 

     

    • 首次适应算法(First Fit):

      算法思想:将空闲分区链以地址递增的顺序连接;在进行内存分配时,从链首开始顺序查找,直到找到一块分区的大小可以满足需求         时,按照该作业的大小,从该分区中分配出内存,将剩下的空闲分区仍然链在空闲分区链中。

           

                                                                                 (图片来源:见水印) 

         优点:高址部分的大的空闲分区得到保留,为大作业的内存分配创造了条件;

         缺点:(1)每次都是优先利用低址部分的空闲分区,造成低址部分产生大量的外碎片。

               (2)每次都是从低址部分查找,使得查找空闲分区的开销增大;

    • 循环首次适应算法(Next Fit)

     算法思想:分配内存时不是从链首进行查找可以分配 内存的空闲分区,而是从上一次分配内存的空闲分区的下一个分区开始查找,直到     找到可以为该进程分配内存的空闲分区。

          

                                                                     (图片来源:见水印)  

       优点:(1)使得空闲分区分布更加均匀;

                  (2)空闲分区的查找开销小; 

       缺点:高址部分的大空闲分区被分小,使得大作业进入无法分配内存;

    • 最佳适应算法(Best Fit)

       算法思想:将空闲分区链中的空闲分区按照空闲分区由小到大的顺序排序,从而形成空闲分区链。每次从链首进行查找合适的空闲分区      为作业分配内存,这样每次找到的空闲分区是和作业大小最接近的,所谓“最佳”.

         

                                                                                (图片来源:见水印)  

         优点:第一次找到的空闲分区是大小最接近待分配内存作业大小的;

         缺点:产生大量难以利用的外部碎片。

    • 最坏适应算法(Worst Fit)

    算法思想:与最佳适应算法刚好相反,将空闲分区链的分区按照从大到小的顺序排序形成空闲分区链,每次查找时只要看第一个空闲分区是否满足即可。

        

                                                                                     (图片来源:见水印)  

       优点:效率高,分区查找方便;

       缺点:当小作业把大空闲分区分小了,那么,大作业就找不到合适的空闲分区。

    二:程序设计

    • 变量及函数
    #define MAXNUMBER 100
    static int PartitionNum;  //内存中空闲分区的个数
    static int FreePartition[MAXNUMBER];  //空闲分区对应的内存
    static int choose;//算法选择
    static int ProcessNum; //进程个数
    static char ProcessName[MAXNUMBER];//进程名字
    static int ProcessNeed[MAXNUMBER];  //进程大小
    static char NameProcessToPartition[MAXNUMBER][MAXNUMBER];//各个进程所在分区位置
    
    static int LeftFreePartition[MAXNUMBER];//剩下空闲内存
    static int LeftProcessNeed[MAXNUMBER];
    
    typedef struct{//涉及到排序用结构体比较好
        int partitionSize;
        int id;
    }sortNeed;
    
    void Enter();//输入分区数和大小、资源数和大小
    void initial();//初始化供4个算法使用
    void display();//显示分区结果
    void FirstFit();//首次适应算法FF
    void NextFit();//循环首次适应算法NF
    void BestFit();//最佳适应算法BF
    void WorstFit();//最坏适应算法WF
    void choose_Algorithm();
    • 四个核心算法
    //首次适应算法FF
    void FirstFit(){
        cout<<"FF"<<endl;
        initial();
        int i,j;
        for (i=0;i<ProcessNum;i++){   //遍历进程
            for (j=0;j<PartitionNum;j++){   //每次从分区的首地址开始查找
                //当系统内存分区足够大的时候,即分配给进程资源
                if (LeftProcessNeed[i] <= LeftFreePartition[j] && LeftFreePartition!=0){
                    LeftFreePartition[j] -= LeftProcessNeed[i];   //扣除分配给进程的资源
                    LeftProcessNeed[i] = 0;  //当内存分区足够才执行,当前进程大小置0
                    NameProcessToPartition[i][j] = ProcessName[i];  //存储各个进程所在的分区位置
                    break;   //一个进程分区完后,立即进行下一个进程的判断
                }
            }
        }
        display();
    }
    
    //循环首次适应算法NF
    void NextFit(){
        cout<<"NF"<<endl;
        initial();
        int i,j,nextPoint = 0;
        bool isWhile;
        for (i=0;i<ProcessNum;i++){
            isWhile = true;
            while(isWhile){     //每次都从当前分区的下一个分区开始查找
                if (LeftFreePartition[nextPoint] >= LeftProcessNeed[i]){
                    LeftFreePartition[nextPoint] -= LeftProcessNeed[i];
                    LeftProcessNeed[i] = 0;
                    NameProcessToPartition[i][nextPoint] = ProcessName[i];
                    nextPoint++;
                    if (nextPoint > PartitionNum - 1){
                        nextPoint = 0;  //当j遍历到分区末尾的时候,返回首位置
                    }
                    isWhile = false;
                }
                else{
                    nextPoint++;
                    if (nextPoint > PartitionNum - 1){
                        nextPoint = 0;  //当j遍历到分区末尾的时候,返回首位置
                    }
                    j++;
                    if(j>=PartitionNum){//避免死循环
                        isWhile=false;
                        j=0;
                    }
    
                }
    
            }
        }
        display();
    }
    
    
    //最佳适应算法BF
    void BestFit(){
        //对分区大小进行排序,每次分配完一个进程的内存大小后,重新排序
        cout<<"BF"<<endl;
        initial();
        int i,j,s,t;
        sortNeed best[MAXNUMBER];
        sortNeed temp;
        for (i=0;i<PartitionNum;i++){
            best[i].partitionSize = FreePartition[i];
            best[i].id = i;
        }
    
        for (i=0;i<ProcessNum;i++){
            //冒泡排序(每次分配完一个进程后,都需要重新排序)
            for (s=0;s < PartitionNum - 1;s++){
                for (t = s;t < PartitionNum - 1;t++){
                    if (best[s].partitionSize > best[t].partitionSize){
                        temp = best[s];
                        best[s] = best[t];
                        best[t] = temp;
                    }
                }
            }
    
            for (j=0;j<PartitionNum;j++){
                if (LeftProcessNeed[i] <= best[j].partitionSize){
                    best[j].partitionSize -= LeftProcessNeed[i];
                    LeftProcessNeed[i] = 0;
    
                    NameProcessToPartition[i][best[j].id] = ProcessName[i];
                    break;
                }
            }
            LeftFreePartition[best[j].id] = best[j].partitionSize;
        }
        display();
    }
    
    //最坏适应算法WF
    void WorstFit(){
        cout<<"WF"<<endl;
        initial();
        int i,j,s,t;
        sortNeed Worst[MAXNUMBER];
        sortNeed temp;
        for (i = 0;i<PartitionNum;i++){
            Worst[i].partitionSize = FreePartition[i];
            Worst[i].id = i;
        }
    
        for (i = 0;i<ProcessNum;i++){
            for (s=0;s<PartitionNum - 1;s++){
                for (t=s;t<PartitionNum - 1;t++){
                    if (Worst[s].partitionSize < Worst[t].partitionSize){
                        temp = Worst[s];
                        Worst[s] = Worst[t];
                        Worst[t] = temp;
                    }
                }
            }
    
            for (j=0;j<PartitionNum;j++){
                if (LeftProcessNeed[i] <= Worst[j].partitionSize){
                    Worst[j].partitionSize -= LeftProcessNeed[i];
                    LeftProcessNeed[j] = 0;
    
                    NameProcessToPartition[i][Worst[j].id] = ProcessName[i];
                    break;
                }
                else{
                    cout<<"Fail to Partition "<<ProcessName[i]<<endl;
                    break;
                }
            }
            LeftFreePartition[Worst[j].id] = Worst[j].partitionSize;
        }
        display();
    
    }

    三:测试结果

    为了方便采用文件流的形式读取数据(分区个数,对应的内存大小,进程个数,对应的进程大小)

    5
    32 16 64 64 16
    5
    7 5 18 22 46

    四:实验源码 

    #include <iostream>
    #include <fstream>
    #include <iomanip>
    #include <stdlib.h>
    using namespace std;
    
    #define MAXNUMBER 100
    static int PartitionNum;  //内存中空闲分区的个数
    static int FreePartition[MAXNUMBER];  //空闲分区对应的内存
    static int choose;//算法选择
    static int ProcessNum; //进程个数
    static char ProcessName[MAXNUMBER];//进程名字
    static int ProcessNeed[MAXNUMBER];  //进程大小
    static char NameProcessToPartition[MAXNUMBER][MAXNUMBER];//各个进程所在分区位置
    
    static int LeftFreePartition[MAXNUMBER];//剩下空闲内存
    static int LeftProcessNeed[MAXNUMBER];
    
    typedef struct{//涉及到排序用结构体比较好
        int partitionSize;
        int id;
    }sortNeed;
    
    void Enter();//输入分区数和大小、资源数和大小
    void initial();//初始化供4个算法使用
    void display();//显示分区结果
    void FirstFit();//首次适应算法FF
    void NextFit();//循环首次适应算法NF
    void BestFit();//最佳适应算法BF
    void WorstFit();//最坏适应算法WF
    void choose_Algorithm();
    
    int main(){
        Enter();
       choose_Algorithm();
        return 0;
    }
    
    //输入分区数和大小、资源数和大小
    void Enter(){
        int i;
    
    
         ifstream inData;
    	inData.open("datainput.txt");
    	//读取数据
    	inData>>PartitionNum;//分区个数
    	 for (i=0;i<PartitionNum;i++){//对应的内存
            inData>>FreePartition[i];
        }
       inData>>ProcessNum;//进程个数
        for (i=0;i<ProcessNum;i++){//初始化名称
            ProcessName[i]=i+65;
        }
    
        for (i=0;i<ProcessNum;i++){
            inData>>ProcessNeed[i];//进程大小
        }
        cout<<"读取数据如下:"<<endl;
        cout<<"进程名称: "<<"\t\t";
        for (i=0;i<ProcessNum;i++){
            cout<<ProcessName[i]<<"\t";
        }
        cout<<endl;
        cout<<"进程大小: "<<"\t\t";
        for (i=0;i<ProcessNum;i++){
            cout<<ProcessNeed[i]<<"\t";
        }
        cout<<endl;
    
        cout<<"分区名称: "<<"\t\t";
        for (i=0;i<PartitionNum;i++){
            cout<<"P"<<i+1<<"\t";
        }
        cout<<endl<<"内存大小: "<<"\t\t";
        for (i=0;i<PartitionNum;i++){
            cout<<FreePartition[i]<<"\t";
        }
    
    cout<<endl<<"----------------------"<<endl;
    
    }
    
    //初始化供4个算法使用
    void initial(){
        int i,j;
        for (i=0;i<ProcessNum;i++){
            for (j=0;j<PartitionNum;j++){
                NameProcessToPartition[i][j] =NULL;
                LeftFreePartition[j] = FreePartition[j];
            }
        }
        for (i=0;i<ProcessNum;i++){
            LeftProcessNeed[i] = ProcessNeed[i];//代替ProcessNeed进行操作
        }
    }
    
    //显示分区结果
    void display(){
        int i;
        cout<<"进程名称: "<<"\t\t";
        for (i=0;i<ProcessNum;i++){
            cout<<ProcessName[i]<<"\t";
        }
        cout<<endl;
        cout<<"进程大小: "<<"\t\t";
        for (i=0;i<ProcessNum;i++){
            cout<<ProcessNeed[i]<<"\t";
        }
        cout<<endl;
    
        cout<<"分区名称: "<<"\t\t";
        for (i=0;i<PartitionNum;i++){
            cout<<"P"<<i+1<<"\t";
        }
        cout<<endl<<"内存大小: "<<"\t\t";
        for (i=0;i<PartitionNum;i++){
            cout<<FreePartition[i]<<"\t";
        }
        cout<<endl<<"分区剩余内存大小: "<<"\t";
        for (i=0;i<PartitionNum;i++){
            cout<<LeftFreePartition[i]<<"\t";
        }
        cout<<endl<<"分区结果:"<<endl;
        for (i=0;i<PartitionNum;i++){
            for (int j = 0;j<ProcessNum;j++){
                if (NameProcessToPartition[j][i]!=NULL){
                    cout<<NameProcessToPartition[j][i]<<": P"<<i+1<<endl;
                }
            }
        }
    }
    
    //首次适应算法FF
    void FirstFit(){
        cout<<"FF"<<endl;
        initial();
        int i,j;
        for (i=0;i<ProcessNum;i++){   //遍历进程
            for (j=0;j<PartitionNum;j++){   //每次从分区的首地址开始查找
                //当系统内存分区足够大的时候,即分配给进程资源
                if (LeftProcessNeed[i] <= LeftFreePartition[j] && LeftFreePartition!=0){
                    LeftFreePartition[j] -= LeftProcessNeed[i];   //扣除分配给进程的资源
                    LeftProcessNeed[i] = 0;  //当内存分区足够才执行,当前进程大小置0
                    NameProcessToPartition[i][j] = ProcessName[i];  //存储各个进程所在的分区位置
                    break;   //一个进程分区完后,立即进行下一个进程的判断
                }
            }
        }
        display();
    }
    
    
    //循环首次适应算法NF
    void NextFit(){
        cout<<"NF"<<endl;
        initial();
        int i,j,nextPoint = 0;
        bool isWhile;
        for (i=0;i<ProcessNum;i++){
            isWhile = true;
            while(isWhile){     //每次都从当前分区的下一个分区开始查找
                if (LeftFreePartition[nextPoint] >= LeftProcessNeed[i]){
                    LeftFreePartition[nextPoint] -= LeftProcessNeed[i];
                    LeftProcessNeed[i] = 0;
                    NameProcessToPartition[i][nextPoint] = ProcessName[i];
                    nextPoint++;
                    if (nextPoint > PartitionNum - 1){
                        nextPoint = 0;  //当j遍历到分区末尾的时候,返回首位置
                    }
                    isWhile = false;
                }
                else{
                    nextPoint++;
                    if (nextPoint > PartitionNum - 1){
                        nextPoint = 0;  //当j遍历到分区末尾的时候,返回首位置
                    }
                    j++;
                    if(j>=PartitionNum){//避免死循环
                        isWhile=false;
                        j=0;
                    }
    
                }
    
            }
        }
        display();
    }
    
    
    //最坏适应算法WF
    void WorstFit(){
        cout<<"WF"<<endl;
        initial();
        int i,j,s,t;
        sortNeed Worst[MAXNUMBER];
        sortNeed temp;
        for (i = 0;i<PartitionNum;i++){
            Worst[i].partitionSize = FreePartition[i];
            Worst[i].id = i;
        }
    
        for (i = 0;i<ProcessNum;i++){
            for (s=0;s<PartitionNum - 1;s++){
                for (t=s;t<PartitionNum - 1;t++){
                    if (Worst[s].partitionSize < Worst[t].partitionSize){
                        temp = Worst[s];
                        Worst[s] = Worst[t];
                        Worst[t] = temp;
                    }
                }
            }
    
            for (j=0;j<PartitionNum;j++){
                if (LeftProcessNeed[i] <= Worst[j].partitionSize){
                    Worst[j].partitionSize -= LeftProcessNeed[i];
                    LeftProcessNeed[j] = 0;
    
                    NameProcessToPartition[i][Worst[j].id] = ProcessName[i];
                    break;
                }
                else{
                    cout<<"Fail to Partition "<<ProcessName[i]<<endl;
                    break;
                }
            }
            LeftFreePartition[Worst[j].id] = Worst[j].partitionSize;
        }
        display();
    
    }
    void choose_Algorithm()
    {
    	cout<<"请选择算法“1-首次适应算法FF,2-循环首次适应算法NF,3-最佳适应算法BF,4-最坏适应算法WF,0-退出”"<<endl;
    
    	cin>>choose;
    	cout<<endl;
    	if (choose==1)
    	{
    		FirstFit();
    		choose_Algorithm();
    	}
    		else if(choose==2)
    		{
    			NextFit();
    			choose_Algorithm();
    		}
    		else if(choose==3){
                BestFit();
                choose_Algorithm();
    		}
    		else if(choose==4){
                WorstFit();
                choose_Algorithm();
    		}
    		else if(choose==0){
              exit(0);
    		}
    	else
    	{
    		cout<<"请输入正确的选择“1-首次适应算法FF,2-循环首次适应算法NF,3-最佳适应算法BF,4-最坏适应算法WF,0-退出”"<<endl;
    		cout<<"------------------------------------------------------"<<endl;
    		choose_Algorithm();  //递归
    	}
    }
    
    
    

     

    展开全文

空空如也

空空如也

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

动态分区分配算法