模拟可变分区管理（大学实验）

// 模拟可变分区存储管理.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
using namespace std;
#include <iostream>
#include <bits/stdc++.h>

#define SIZE 1000
struct Node {
    int addr;//起始地址
    int size;       //空间大小
    
    int state;      //当前状态，1表示占用，0表示空闲
    Node* pre;
    Node* next;
};
Node* head=NULL;         //头指针
Node* nowList=NULL;      //现指针

Node* init()         //此为初始化函数，在确定分配方法时调用
{
    Node* p = (Node*)malloc(sizeof(Node));
    p->addr = 1;    //设起始地址为1
    p->size = 1000; //设大小为1000
    p->state = 0;   //0为未被占用
    p->pre = NULL;
    p->next = NULL;
    return p;
}

int Malloc(int psize, Node* p) {        //此函数为分配内存的函数
    
    if (p->size == psize) {             //分区整块分配
        p->state = 1;
    }
    else {                              //分割分区
        Node* newArea = (Node*)malloc(sizeof(Node));
        newArea->addr = p->addr + psize;
        newArea->size = p->size - psize;
        newArea->state = 0;

        p->size = psize;                //该大小的区块已经被分配的意思
        p->state = 1;                   //该大小的区块已经被分配的意思

        if(p->next!=NULL)p->next->pre = newArea;
        newArea->next = p->next;        
        p->next = newArea;
        newArea->pre = p;
    }
    return 1;
}

void FreeMalloc(Node* p) {
    int flag = 1;
    Node* Pre = p->pre;
    Node* Next = p->next;
    if (p != head && p->pre->state == 0) {
        Pre->size = Pre->size + p->size;
        Pre->next = Next;
        if (Next != NULL)Next->pre = Pre;
        free(p);
        p = Pre;
        flag = 0;
    }
    if (p->next!= NULL && p->next->state == 0) {
        Next = p->next;
        p->size = p->size + Next->size;
        p->next = Next->next;
        if(Next->next!=NULL)Next->next->pre = p;
        p->state = 0;
        free(Next);
        flag = 0;
    }
    if (flag == 1) {
        p->state = 0;
    }
}
void displayAllocTable() {
    Node* p = head;
    printf("\n\n           --------------------------------------madeby dayou-");
    printf("\n           -%5s %5s %5s %5s   -\n", "起始地址", "终止地址", "长度", "当前状态");

    while (p) {
        printf("\n           -%5d    %5d    %5d  ", p->addr, p->addr + p->size, p->size);
        if (p->state == 1)printf("占用      -");
        else if (p->state == 0)printf("空闲      -");
        p = p->next;
    }
    printf("\n           --------------------------------------\n");
}


int main()
{
    head = init();
    nowList = head;
    int t = 1;
    char c = 'q';
    char c2 = 'q';
    int psize = 0;
    int start = 0;
    printf("\n                      ----------------------------\n");
    printf("                      |                          |\n");
    printf("                      |内存动态分区分配方式的模拟|           \n");
    printf("                      |                          |\n");
    printf("                      ----------------------------\n\n");
    printf("        |1:循环首次适应算法\n");
    printf("        |2:最佳适应算法\n");
    printf("        |3:最坏适应算法\n");
    printf("        |其他任意键:退出\n");
    printf("        |那么您的选择是---> ");
    cin >> c;
    
    if (c != '1' && c != '2' && c != '3' )return 0;



    if (c == '1') {//循环首次适应算法
        while (t != 0) {
            int c2 = 0;
            printf("\n\n                          ____________________\n");
            printf("                          *****请选择功能*****\n");
            printf("        |1:分配\n");
            printf("        |2:释放\n");
            printf("        |那么您的选择是---> ");
            cin >> c2;
            if (c2 != 1 && c2 != 2)continue;
            if (c2 == 1) {
                printf("\n          请输入空间大小  ");
                scanf("%d", &psize);
                Node* temp = nowList;
                while (nowList) {
                    if (nowList->state == 0 && nowList->size >= psize) {
                        Malloc(psize, nowList);                                         //若找到合适空间，立即分配内存
                        
                        displayAllocTable();
                        break;
                    }
                    nowList = nowList->next == NULL ? head : nowList->next;             //如果到了队尾 返回队首
                    if (nowList == temp) {
                        printf("\n          内存不足，分配失败\n");
                        break;
                    }                                   //判断是否循环了一圈
                }
            }//此处  循环首次适应算法 分配 结束
            if (c2 == 2) {
                printf("\n          请输入要释放的内存块的起始地址 ");
                scanf("%d", &start);
                Node* temp = head;nowList;
                while (temp) {
                    if (temp->state == 1 && temp->addr == start) {
                        FreeMalloc(temp);                                         //若找到合适空间，立即分配内存
                        cout << "           已完成内存释放" << endl;
                        displayAllocTable();
                        break;
                    }
                    temp = temp->next;
                    if (temp == NULL) {                           //循环完毕仍然没有找到
                        printf("\n          未找到相应地址开头的内存块\n");
                        break;
                    }
                }
            }//分配结束
        }//不断循环
    }//循环首次适应算法结束

    else if (c == '2') {//最佳适应算法
        while (t != 0) {
            int c2 = 0;
            printf("\n\n                          ____________________\n");
            printf("                          *****请选择功能*****\n");
            printf("        |1:分配\n");
            printf("        |2:释放\n");
            printf("        |那么您的选择是---> ");
            cin >> c2;
            if (c2 != 1 && c2 != 2)continue;
            if (c2 == 1) {
                printf("\n          请输入空间大小  ");
                scanf("%d", &psize);
                Node* p = head;
                Node* minP = NULL;
                int minSize = 1001;
                while (p) {
                    if (p->state == 0 && p->size >= psize) {
                        if (p->size < minSize) {
                            minSize = p->size;
                            minP = p;
                        }
                    }
                    p = p->next;
                }
                if (minP == NULL) {
                    printf("\n          内存不足，分配失败\n");
                }
                else {
                    Malloc(psize, minP);//将空间最小且能装下的内存空间分配
                    
                    displayAllocTable();
                    
                }
            }
            else if (c2 == 2) {//分配
                printf("\n          请输入要释放的内存块的起始地址 ");
                scanf("%d", &start);
                Node* temp = head;
                while (temp) {
                    if (temp->state == 1 && temp->addr == start) {
                        FreeMalloc(temp);                                         //若找到合适空间，立即分配内存
                        cout << "           已完成内存释放" << endl;
                        displayAllocTable();
                        break;
                    }
                    temp = temp->next;
                    if (temp == NULL) {                           //循环完毕仍然没有找到
                        printf("\n          未找到相应地址开头的内存块\n");
                        break;
                    }
                }
            }//分配结束
        }
    }
    else if (c == '3') {//最坏适应算法
        while (t != 0) {
            int c2 = 0;
            printf("\n\n                          ____________________\n");
            printf("                          *****请选择功能*****\n");
            printf("        |1:分配\n");
            printf("        |2:释放\n");
            printf("        |那么您的选择是---> ");
            cin >> c2;
            if (c2 != 1 && c2 != 2)continue;
            if (c2 == 1) {
                printf("\n          请输入空间大小  ");
                scanf("%d", &psize);
                Node* p = head;
                Node* maxP = NULL;
                int maxSize = -1;
                while (p) {
                    if (p->state == 0 && p->size >= psize) {
                        if (p->size > maxSize) {
                            maxSize = p->size;
                            maxP = p;
                        }
                    }
                    p = p->next;
                }
                if (maxP == NULL) {
                    printf("\n          内存不足，分配失败\n");
                }
                else {
                    Malloc(psize, maxP);//将空间最大且能装下的内存空间分配
                    
                    displayAllocTable();
                }
            }
            else if (c2 == 2) {
                printf("\n          请输入要释放的内存块的起始地址 ");
                scanf("%d", &start);
                Node* temp = head;
                while (temp) {
                    if (temp->state == 1 && temp->addr == start) {
                        FreeMalloc(temp);                                         //若找到合适空间，立即分配内存
                        cout << "           已完成内存释放" << endl;
                        displayAllocTable();
                        break;
                    }
                    temp = temp->next;
                    if (temp == NULL) {                           //循环完毕仍然没有找到
                        printf("\n          未找到相应地址开头的内存块\n");
                        break;
                    }
                }
            }
        }

    }
    


    return 0;
}

部分数据结构参考了别人的代码