「 操作系统 」 - 首次适应算法和最佳适应算法（指针模拟分配过程）

实现程序内存的动态分配

首次适应算法：

找到第一个满足程序的内存块，并将其分配给程序

最佳适应算法：

找到所有的满足程序的内存块，并将其中最小的内存块分配给程序

#include <iostream>
#include <string.h>
#include <stdio.h>

using namespace std;

struct node{
    
    int st,size,num;
    bool work;
    node *next,*pre;
    node(){
        work = false;
        st = 0;
        next = NULL;
        pre = NULL;
    }
}*add,*mem;

int work_num,oper,Size;

void show(){
    
    printf("------------------------------------------------------------------------\n\n");
    
    printf("\t\t当前的内存分配情况如下:\n\n");
    
    node *now = mem;
    
    printf("\t起始地址\t空间大小\t工作状态\t作业号\t\n\n");
    
    while(true){
        printf("\t%d\t\t%d kb\t\t%s\t\t",now->st,now->size,now->work?"Busy":"Free");
        if(now->work) printf("%d\t",now->num);
        printf("\n\n");
        if(now->next==NULL){
            break;
        }
        now = now->next;
    }
    
    printf("------------------------------------------------------------------------\n\n");
    
    
}

bool find1(){
    //找最小的
    node *now = mem;
    node *get = NULL;
    while(true){
        if(!now->work){
            if(now->size>=Size){
                //找出所有的可放置内存块中内存最小的
                if(get==NULL){
                    get = now;
                }else{
                    if(get->size > now->size){
                        get = now;
                    }
                }
            }
        }
        if(now->next==NULL) break;
        now = now->next;
    }
    // 若找不到放置位置 返回不可放置
    if(get==NULL) return false;
    
    // 更新内存情况
    get->work = true;
    get->num = work_num;
    if(get->size>Size){
        add = new node();
        add->size = get->size - Size;
        get->size = Size;
        add->st = get->st + get->size;
        add->next = get->next;
        get->next = add;
        add->pre = get;
    }
    
    return true;
}

bool find2(){
    //找最前面的
    node *now = mem;
    while(true){
        if(!now->work){
            if(now->size>=Size){
                //找到第一个可放置的内存空间 更新内存状况 返回分配结果
                now->work = true;
                now->num = work_num;
                
                if(now->size>Size){
                    add = new node();
                    add->size = now->size - Size;
                    now->size = Size;
                    add->st = now->st + now->size;
                    add->next = now->next;
                    now->next = add;
                    add->pre = now;
                    
                }
                return true;
            }
        }
        if(now->next==NULL) break;
        now = now->next;
    }
    return false;
}

bool find(int ope){
    
    // 分配内存操作
    
    if(ope){
        //最佳适应算法
        return find1();
    }else{
        //首次适应算法
        return find2();
    }
}

bool reget(){
    
    // 回收内存操作
    
    node *now = mem;
    while(true){
        
        if(now->num==work_num&&now->work){
            //找到对应工作号且在工作的内存区
            
            node *pre = now,*next = now->next;
            int pre_unused_memSize = 0,next_unused_memSize = 0;
            
            //将空闲的内存区合并
            while(pre->pre!=NULL&&!pre->pre->work){
                
                pre_unused_memSize += pre->size;
                pre = pre->pre;
            }
            while(next!=NULL&&!next->work){
                next_unused_memSize += next->size;
                next = next->next;
            }
            now = pre;
            now->next = next;
            now->size += pre_unused_memSize + next_unused_memSize;
            now->work = false;
            if(next!=NULL) next->pre = now;
            return true;
        }
        
        if(now->next==NULL){
            break;
        }
        now = now->next;
    }
    
    return false;
}

void work(int ope){
    
    // 执行操作
    
    while(true){
        printf("\n\t1: 分配内存  2: 回收内存  0: 退出\n\n请输入操作:");
        scanf("%d",&oper);
        printf("\n");
        if(oper==1){
            
            // 分配内存
            
            printf("请输入作业号: ");
            scanf("%d",&work_num);
            printf("\n");
            printf("请输入需要分配的内存大小(kb): ");
            scanf("%d",&Size);
            printf("\n");
            if(find(ope)){
                printf("内存分配成功！\n\n");
            }else{
                printf("内存分配失败！\n\n");
            }
            show();
        }else if(oper==2){
            
            // 回收内存
            
            printf("请输入作业号: ");
            scanf("%d",&work_num);
            printf("\n");
            if(reget()){
                printf("\t\t内存回收成功！\n\n");
            }else{
                printf("\t\t内存回收失败！\n\n");
            }
            show();
        }else{
            // 操作结束
            
            break;
        }
    }
}

void delete_mem(node *now){
    // 清空内存
    if(now->next!=NULL) delete_mem(now->next);
    delete now;
}

int main()
{
    
    int ope;
    while(true){
        printf("\t\t请选择需要模拟的分配算法\n\n\t\t0\t首次适应算法\n\n\t\t1\t最佳适应算法\n\n");
        printf("\t\t你的选择是 : ");
        scanf("%d",&ope);
        printf("\n");
        mem = new node(); mem->size = 1000;
        if(ope){
            //最佳适应算法  找到最小可存储空间
            work(ope);
            printf("\t\t最佳适应算法模拟结束\n\n\n");
            printf("-----------------------------------------------------------------------\n\n");
        }else{
            //首次适应算法  找到第一个可存储空间
            work(ope);
            printf("\t\t首次适应算法模拟结束\n\n\n");
            printf("-----------------------------------------------------------------------\n\n");
        }
        delete_mem(mem);
    }
    return 0;
}