實現程式記憶體的動態分配

首次適應演算法：

找到第一個滿足程式的記憶體塊，並將其分配給程式

最佳適應演算法：

找到所有的滿足程式的記憶體塊，並將其中最小的記憶體塊分配給程式

#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;
}