实验七 动态分区分配方式的模拟

、假设初始状态下，可用的内存空间为640KB，并有下列的请求序列：

•作业1申请130KB。

•作业2申请60KB。

•作业3申请100KB。

•作业2释放60KB。

•作业4申请200KB。

•作业3释放100KB。

•作业1释放130KB。

•作业5申请140KB。

•作业6申请60KB。

•作业7申请50KB。

•作业6释放60KB。

请分别采用首次适应算法和最佳适应算法，对内存块进行分配和回收，要求每次分配和回收后显示出空闲分区链的情况。

这里假设申请模式为1，释放为2

作业”作业1申请130KB“格式 1 1 130

首次适应

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

typedef struct node
{
    int id;
    int space;
    int addr[2];
    struct node *next;
} node;
node head;

int add_memory(node *job)//分配空间
{
    if (head.space < job->space)
        return 0;
    node *t = (node *)malloc(sizeof(node));
    t->id = job->id;
    t->space = job->space;
    t->addr[0] = head.addr[0];
    t->addr[1] = head.addr[0] + job->space - 1;
    t->next = NULL;

    head.addr[0] = t->addr[1] + 1;
    head.space -= t->space;

    node *p = head.next;
    node *q = &head;
    while (p)
    {
        q = q->next;
        p = p->next;
    }
    q->next = t;
    return 1;
}

void merge_memory()//合并相邻空闲空间
{
    node *p = head.next;
    node *t = &head;
    while (p->next)
    {
        if (p->id == -1 && p->next->id == -1)
        {
            p->addr[1] = p->next->addr[1];
            p->space += p->next->space;
            node *q = p->next;
            p->next = q->next;
            free(q);
        }
        else
        {
            t = t->next;
            p = p->next;
        }
    }
    if (p->id == -1)
        if (p->addr[1] == head.addr[0] + 1)
        {
            head.addr[0] = p->addr[0];
            head.space = p->space + head.space;
            t->next = NULL;
            free(p);
        }
}
void printspace()
{
    node *p = head.next;

    while (p)
    {
        if (p->id == -1)
            printf("%d->", p->space);
        p = p->next;
    }
    printf("%d", head.space);
    printf("\n");
}
int find_memory(node *job)//寻找空间
{
    node *p = head.next;
    node *q = &head;
    int i = 0;
    while (p)
    {
        if (p->space == job->space)
        {
            p->id = job->id;
            return 1;
        }
        else if (p->space > job->space && p->id == -1)
        {
            node *t = (node *)malloc(sizeof(node));

            t->id = job->id;
            t->space = job->space;
            t->addr[0] = p->addr[0];
            t->addr[1] = p->addr[0] + job->space - 1;
            t->next = p;

            q->next = t;

            p->addr[0] = p->addr[0] + job->space;
            p->space = p->space - job->space;

            return 1;
        }
        else
        {
            q = q->next;
            p = p->next;
        }
    }
    return 0;
}
void free_memory(node *job)//释放空间
{
    node *p = head.next;
    node *q = &head;
    while (p)
    {
        if (p->id == job->id)
        {
            p->id = -1;

            merge_memory();
            return;
        }
        else
        {
            q = q->next;
            p = p->next;
        }
    }
}
int alloc(int mode, node *job)//申请空间
{
    int k;
    switch (mode)
    {
    case 1:
        k = find_memory(job);
        if (k)
        {
            printspace();
            return 1;
        }
        else
            k = add_memory(job);
        if (k)
        {
            printspace();
            return 1;
        }
        else
            return 0;
        break;
    case 2:

        free_memory(job);
        printspace();
        return 1;
        break;
    default:
        return 0;
        break;
    }
    return 0;
}
//首次适应
int main()
{
    head.id = 0;
    head.space = 640;
    head.next = NULL;
    head.addr[0] = 0;
    head.addr[1] = 639;
    node t;
    int k = 0;

    FILE *fp = fopen("test.txt", "r"); // 打开文件
    if (fp == NULL)
    {
        printf("无法打开文件\n");
        return 1;
    }
    for (int i = 0; i < 11; i++)
    {
        fscanf(fp, "%d %d %d", &k, &t.id, &t.space);
        alloc(k, &t);
    }
    fclose(fp); // 关闭文件
    system("pause");
    return 0;
}

最佳适应 

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

typedef struct node
{
    int id;
    int space;
    int addr[2];
    struct node *next;
} node;
node head;

int add_memory(node *job)
{
    if (head.space < job->space)
        return 0;
    node *t = (node *)malloc(sizeof(node));
    t->id = job->id;
    t->space = job->space;
    t->addr[0] = head.addr[0];
    t->addr[1] = head.addr[0] + job->space - 1;
    t->next = NULL;

    head.addr[0] = t->addr[1] + 1;
    head.space -= t->space;

    node *p = head.next;
    node *q = &head;
    while (p)
    {
        q = q->next;
        p = p->next;
    }
    q->next = t;
    return 1;
}

void merge_memory()
{
    node *p = head.next;
    node *t = &head;
    while (p->next)
    {
        if (p->id == -1 && p->next->id == -1)
        {
            p->addr[1] = p->next->addr[1];
            p->space += p->next->space;
            node *q = p->next;
            p->next = q->next;
            free(q);
        }
        else
        {
            t = t->next;
            p = p->next;
        }
    }
    if (p->id == -1)
        if (p->addr[1] == head.addr[0] + 1)
        {
            head.addr[0] = p->addr[0];
            head.space = p->space + head.space;
            t->next = NULL;
            free(p);
        }
}
void printspace()
{
    node *p = head.next;

    while (p)
    {
        if (p->id == -1)
            printf("%d->", p->space);
        p = p->next;
    }
    printf("%d", head.space);
    printf("\n");
}
int find_memory(node *job)
{
    node *p = head.next;
    node *q = &head;
    node *minjob = NULL;
    int i = 0;
    while (p)
    {
        if (p->space == job->space)
        {
            p->id = job->id;
            return 1;
        }
        else if (p->space > job->space && p->id == -1)
        {
            if (minjob == NULL || p->space < minjob->space)
                minjob = p;
            q = q->next;
            p = p->next;
        }
        else
        {
            q = q->next;
            p = p->next;
        }
    }
    if (minjob != NULL)
    {
        if (minjob->space > head.space && head.space > job->space)
        {
            add_memory(job);
            return 1;
        }
        p = head.next;
        q = &head;
        while (p != minjob)
        {
            q = q->next;
            p = p->next;
        }
        node *t = (node *)malloc(sizeof(node));

        t->id = job->id;
        t->space = job->space;
        t->addr[0] = p->addr[0];
        t->addr[1] = p->addr[0] + job->space - 1;
        t->next = p;

        q->next = t;

        p->addr[0] = p->addr[0] + job->space;
        p->space = p->space - job->space;

        return 1;
    }
    return 0;
}
void free_memory(node *job)
{
    node *p = head.next;
    node *q = &head;
    while (p)
    {
        if (p->id == job->id)
        {
            p->id = -1;

            merge_memory();
            return;
        }
        else
        {
            q = q->next;
            p = p->next;
        }
    }
}
int alloc(int mode, node *job)
{
    int k;
    switch (mode)
    {
    case 1:
        k = find_memory(job);
        if (k)
        {
            printspace();
            return 1;
        }
        else
            k = add_memory(job);
        if (k)
        {
            printspace();
            return 1;
        }
        else
            return 0;
        break;
    case 2:

        free_memory(job);
        printspace();
        return 1;
        break;
    default:
        return 0;
        break;
    }
    return 0;
}

int main()
{
    head.id = 0;
    head.space = 640;
    head.next = NULL;
    head.addr[0] = 0;
    head.addr[1] = 639;
    node t;
    int k = 0;

    FILE *fp = fopen("test.txt", "r"); // 打开文件
    if (fp == NULL)
    {
        printf("无法打开文件\n");
        return 1;
    }
    for (int i = 0; i < 11; i++)
    {
        fscanf(fp, "%d %d %d", &k, &t.id, &t.space);
        alloc(k, &t);
    }
    fclose(fp); // 关闭文件
    system("pause");
    return 0;
}

数据

1 1 130
1 2 60
1 3 100
2 2 60
1 4 200
2 3 100
2 1 130
1 5 140
1 6 60
1 7 50
2 6 60