操作系统 首次适应算法 最佳适应算法(C++)

最新推荐文章于 2023-05-18 18:33:16 发布
最新推荐文章于 2023-05-18 18:33:16 发布
阅读量4.5k 收藏 53
点赞数 4
分类专栏： # 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WHY995987477/article/details/106356190/
版权

首次适应算法代码

#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <string>
#include <string.h>
#include <cstdio>
#include <cstdlib>
#include <queue>
using namespace std;
const int maxn = 10;
int N;          ///操作次数
int init_room;  ///总的内存可用空间
char s[] = "申请";

typedef struct Node{
    int start;  ///地址起点
    int ended;  ///地址终点
    int room;   ///地址长度
    int id = 0;     ///任务序号(空闲内存都为0，占用则为对应的序号)
    Node* next;
}Node;

Node* HE;  ///空闲内存链表的头结点
Node* HF;   ///占用内存链表的头结点

void add_next(int start, int ended, int room, int id, Node* next){
    next -> start = start;
    next -> ended = ended;
    next -> room = room;
    next -> id = id;
    next -> next = NULL;
}

void init(){
    HE = (Node*)malloc(sizeof(Node));
    HF = (Node*)malloc(sizeof(Node));
    HE -> next = (Node*)malloc(sizeof(Node));
    if(HE == NULL || HF == NULL || HE -> next == NULL){
        cout << "链表头结点分配内存失败或链表尾部添加结点时分配内存失败" << endl;
        exit(-1);
    }

    add_next(0, init_room - 1, init_room, 0, HE -> next);
    HF -> next = NULL;
}

void out_put_empty(){
    Node* p = HE -> next;
    cout << "空闲内存情况"  << endl;
    cout << "---------------------------" << endl;
    printf("%10s %10s %10s\n", "起始地址", "结束地址", "内存大小");
    while(p != NULL){
        printf("%10d %10d %10d\n", p -> start, p -> ended, p -> room);
        p = p -> next;
    }
    cout << "---------------------------" << endl;
}

void out_put_full(){
    Node* p = HF -> next;
    cout << "占用内存情况"  << endl;
    cout << "---------------------------" << endl;
    printf("%10s %10s %10s %10s\n", "任务id", "起始地址", "结束地址", "内存大小");
    while(p != NULL){
        printf("%10d %10d %10d %10d\n",p -> id, p -> start, p -> ended, p -> room);
        p = p -> next;
    }
    cout << "---------------------------" << endl;
}

/*
 * 指向尾结点
 */
Node* get_tail(){
    Node* p = HF;
    while(p -> next != NULL){
        p = p -> next;
    }
    return p;
}

void insert_full(Node* p, int id, int room){
    Node* tail = get_tail();
    tail -> next = (Node*)malloc(sizeof(Node));
    if(tail -> next == NULL){
        cout << "占用内存链表尾部添加结点时分配内存失败" << endl;
        exit(-1);
    }
    add_next(p -> start, p -> start + room - 1, room, id, tail -> next);
}

void delete_emtpy(Node* p, int room){
    p -> start += room;
    p -> room -= room;
}

/*
 * 在空闲内存中查找是否有连续的room空间
 * 有则返回空闲内存块的指针，没有则返回NULL
 */
bool search_delete_empty_insert_full(int id, int room){
    Node* p = HE -> next;
    while(p != NULL){
        if(p -> room >= room){
            insert_full(p, id, room);
            delete_emtpy(p, room);
            return true;
        }
        p = p -> next;
    }
}

void free_full(Node* p, Node* pre){
    pre -> next = p -> next;
    free(p);
    p = NULL;
}

/*
 * 将释放的空间加回空闲内存链表
 */
void add_empty(Node* pFull){
    Node* p = HE;
    while(p != NULL){
        if(p -> next == NULL || !(pFull -> start > p -> next -> ended)){
            Node * new_empty = (Node*)malloc(sizeof(Node));
            if(new_empty == NULL){
                cout << "空闲内存链表创建新的结点失败" << endl;
                exit(-1);
            }
            new_empty -> start = pFull -> start;
            new_empty -> ended = pFull -> ended;
            new_empty -> room = pFull -> room;
            new_empty -> next = p -> next;
            p -> next = new_empty;
            return ;
        }
        p = p -> next;
    }
    return ;
}

bool search_id_free_full_add_empty(int id){
    Node* p = HF -> next;
    Node* pre = HF;
    while(p != NULL){
        if(p -> id == id){
            add_empty(p);
            free_full(p, pre);
            return true;
        }
        pre = p;
        p = p -> next;
    }
    return false;
}

void conbine_empty(){
    Node* p = HE -> next;
    //printf("%d %d\n", p == NULL, p -> next == NULL);
    while(p != NULL && p -> next != NULL){
        if(p -> ended + 1 == p -> next -> start){
            p -> ended = p -> next -> ended;
            p -> room += p -> next -> room;
            Node* tem = p -> next;
            p -> next = p -> next -> next;
            free(tem);
            tem = NULL;
        }else{
            p = p -> next;
        }
    }
}

void solve(int id, char* behave, int room){
    if(strcmp(behave, s) == 0){///申请操作
        if(search_delete_empty_insert_full(id, room)){
            cout << "申请成功" << endl;
        }else{
            cout << "空间不足，申请失败" << endl;
        }
    }else{///释放
        if(search_id_free_full_add_empty(id)){
            cout << "释放成功" << endl;
        }else{
            cout << "无此任务，释放失败" << endl;
        }
    }
    conbine_empty();
}

int main(){
    cout << "请输入操作次数：";
    cin >> N;
    cout << "请输入内存可用空间：";
    cin >> init_room;
    getchar();
    init();
    while(N--){
        int id, room;
        char behave[maxn];   ///要执行的操作
        scanf("作业%d %s %dKB", &id, behave, &room);
        getchar();
        solve(id, behave, room);
        out_put_empty();
        out_put_full();
    }
    return 0;
}
/*
11
640
作业1 申请 130KB
作业2 申请 60KB
作业3 申请 100KB
作业2 释放 60KB
作业4 申请 200KB
作业3 释放 100KB
作业1 释放 130KB
作业5 申请 140KB
作业6 申请 60KB
作业7 申请 50KB
作业8 申请 60KB
*/

最佳适应代码

合并连续空闲内存的模块要改
增加一个空闲内存链表大小 从小到大排序的模块，用插入排序就好，这里不用改变指针的排序方式，用结点赋值的方式。

#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <string>
#include <string.h>
#include <cstdio>
#include <cstdlib>
#include <queue>
using namespace std;
const int maxn = 10;
int N;          ///操作次数
int init_room;  ///总的内存可用空间
char s[] = "申请";

typedef struct Node{
    int start;  ///地址起点
    int ended;  ///地址终点
    int room;   ///地址长度
    int id = 0;     ///任务序号(空闲内存都为0，占用则为对应的序号)
    Node* next;
}Node;

Node* HE;  ///空闲内存链表的头结点
Node* HF;   ///占用内存链表的头结点

void add_next(int start, int ended, int room, int id, Node* next){
    next -> start = start;
    next -> ended = ended;
    next -> room = room;
    next -> id = id;
    next -> next = NULL;
}

void init(){
    HE = (Node*)malloc(sizeof(Node));
    HF = (Node*)malloc(sizeof(Node));
    HE -> next = (Node*)malloc(sizeof(Node));
    if(HE == NULL || HF == NULL || HE -> next == NULL){
        cout << "链表头结点分配内存失败或链表尾部添加结点时分配内存失败" << endl;
        exit(-1);
    }

    add_next(0, init_room - 1, init_room, 0, HE -> next);
    HF -> next = NULL;
}

void out_put_empty(){
    Node* p = HE -> next;
    cout << "空闲内存情况"  << endl;
    cout << "---------------------------" << endl;
    printf("%10s %10s %10s\n", "起始地址", "结束地址", "内存大小");
    while(p != NULL){
        printf("%10d %10d %10d\n", p -> start, p -> ended, p -> room);
        p = p -> next;
    }
    cout << "---------------------------" << endl;
}

void out_put_full(){
    Node* p = HF -> next;
    cout << "占用内存情况"  << endl;
    cout << "---------------------------" << endl;
    printf("%10s %10s %10s %10s\n", "任务id", "起始地址", "结束地址", "内存大小");
    while(p != NULL){
        printf("%10d %10d %10d %10d\n",p -> id, p -> start, p -> ended, p -> room);
        p = p -> next;
    }
    cout << "---------------------------" << endl;
}

/*
 * 指向尾结点
 */
Node* get_tail(){
    Node* p = HF;
    while(p -> next != NULL){
        p = p -> next;
    }
    return p;
}


void insert_full(Node* p, int id, int room){
    Node* tail = get_tail();
    tail -> next = (Node*)malloc(sizeof(Node));
    if(tail -> next == NULL){
        cout << "占用内存链表尾部添加结点时分配内存失败" << endl;
        exit(-1);
    }
    add_next(p -> start, p -> start + room - 1, room, id, tail -> next);
}

void delete_emtpy(Node* p, int room){
    p -> start += room;
    p -> room -= room;
}

/*
 * 在空闲内存中查找是否有连续的room空间
 * 有则返回空闲内存块的指针，没有则返回NULL
 */
bool search_delete_empty_insert_full(int id, int room){
    Node* p = HE -> next;
    while(p != NULL){
        if(p -> room >= room){
            insert_full(p, id, room);
            delete_emtpy(p, room);
            return true;
        }
        p = p -> next;
    }
}

void free_full(Node* p, Node* pre){
    pre -> next = p -> next;
    free(p);
    p = NULL;
}

/*
 * 将释放的空间加回空闲内存链表
 */
void add_empty(Node* pFull){
    Node* p = HE;
    while(p != NULL){
        if(p -> next == NULL || !(pFull -> start > p -> next -> ended)){
            Node * new_empty = (Node*)malloc(sizeof(Node));
            if(new_empty == NULL){
                cout << "空闲内存链表创建新的结点失败" << endl;
                exit(-1);
            }
            new_empty -> start = pFull -> start;
            new_empty -> ended = pFull -> ended;
            new_empty -> room = pFull -> room;
            new_empty -> next = p -> next;
            p -> next = new_empty;
            return ;
        }
        p = p -> next;
    }
    return ;
}

bool search_id_free_full_add_empty(int id){
    Node* p = HF -> next;
    Node* pre = HF;
    while(p != NULL){
        if(p -> id == id){
            add_empty(p);
            free_full(p, pre);
            return true;
        }
        pre = p;
        p = p -> next;
    }
    return false;
}

void conbine_empty(){
    Node* p = HE -> next;
    while(p != NULL && p -> next != NULL){
        Node* p2 = p -> next;
        Node* pre = p;
        bool flag = false;///标记是否有发生合并
        while(p2 != NULL){
            if(p -> ended + 1 == p2 -> start){
                p -> ended = p2 -> ended;
                p -> room += p2 -> room;
                pre -> next = p2 -> next;
                free(p2);
                p2 = NULL;
                flag = true;
            }
            else{
                pre = p2;
                p2 = p2 -> next;
            }
        }
        if(!flag){
            p = p -> next;
        }
    }
}

void swap_Node(Node* a, Node* b){
    Node tem = *a;
    a -> start = b -> start;
    a -> ended = b -> ended;
    a -> room = b -> room;

    b -> start = tem.start;
    b -> ended = tem.ended;
    b -> room= tem.room;
}

void sort_empty(){
    Node* p = HE;
    while(p != NULL && p -> next != NULL){
        Node* tem = p -> next;
        Node* pmini = tem;
        while(tem != NULL){
            if(tem -> room < pmini -> room){
                pmini = tem;
            }
            tem = tem -> next;
        }
        swap_Node(p -> next, pmini);
        p = p -> next;
    }
}

void solve(int id, char* behave, int room){
    if(strcmp(behave, s) == 0){///申请操作
        if(search_delete_empty_insert_full(id, room)){
            cout << "申请成功" << endl;
        }else{
            cout << "空间不足，申请失败" << endl;
        }
    }else{///释放
        if(search_id_free_full_add_empty(id)){
            cout << "释放成功" << endl;
        }else{
            cout << "无此任务，释放失败" << endl;
        }
    }
    conbine_empty();
    sort_empty();
}

int main(){
    cout << "请输入操作次数：";
    cin >> N;
    cout << "请输入内存可用空间：";
    cin >> init_room;
    getchar();
    init();
    while(N--){
        int id, room;
        char behave[maxn];   ///要执行的操作
        scanf("作业%d %s %dKB", &id, behave, &room);
        getchar();
        solve(id, behave, room);
        out_put_empty();
        out_put_full();
    }
    return 0;
}
/*

11
640
作业1 申请 130KB
作业2 申请 60KB
作业3 申请 100KB
作业2 释放 60KB
作业4 申请 200KB
作业3 释放 100KB
作业1 释放 130KB
作业5 申请 140KB
作业6 申请 60KB
作业7 申请 50KB
作业8 申请 60KB

*/
Authur_gyc
关注
  • 4
    点赞
  • 踩
  • 53
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
首次适应算法主存空间的分配和回收C语言源代码
04-01
在可变分区管理方式下，采用首次适应算法（最先适应算法）实现主存空间的分配和回收。操作系统课程设计，用C语言实现。在VC6.0上调试通过。
内存分区分配--首次适应算法
m0_72151428的博客
05-13 2034
输入内存的大小和阈值minsize，按照首次适应算法进行连续的分区分配。在划分时，若剩余的内存小于等于minsize，则将整块内存分配给该进程不再进行划分。
首次适应算法 C语言实现
weixin_45761769的博客
12-02 1万+
广东工业大学 操作系统实验 用C语言实现采用首次适应算法的动态分区分配过程和回收过程。 其中，空闲分区通过空闲分区链（表）来管理；在进行内存分配时，系统优先使用空闲区低端的空间，要求每次分配和回收后显示出空闲内存分区链的情况。 #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define FREE 0 #define BUSY 1 #define Max_length 640 typedef s
操作系统：动态分区存储（首次适应算法、最佳适应算法）
qq_53062311的博客
04-25 8295
操作系统：动态分区存储（首次适应算法、最佳适应算法）
带有详细注释的操作系统首次适应法C++程序
hanmo22357的博客
12-19 342
【代码】带有详细注释的操作系统首次适应法C++程序。
C/C++-内存分配算法-操作系统课程设计-首次适应算法-循环首次适应算法-最佳适应算法-最坏适应算法
02-02
其中，空闲分区通过空闲分区链表来管理，分别采用首次适应算法、循环首次适应算法、最佳适应算法、最坏适应算法进行内存块的分配和回收，同时显示内存块分配和回收后空闲内存分区链的情况。 基本功能：设计与实现...
操作系统实验之动态分区算法（首次适应，循环首次适应，最佳适应，最坏适应）
11-29
代码主体非本人原创，由于测试中发现问题经本人修改后上传。...该资源VS2010下可直接使用。优化了原代码中当出现请求内存块大小大于现有内存块大小时...可实现首次适应算法，循环首次适应算法，最佳适应算法，最坏适应算法
C语言写的操作系统循环首次适应算法 首次适应算法 最佳适应算法
05-27
操作系统 循环首次适应算法 首次适应算法 最佳适应算法 回收内存 分配内存设计一个可变式分区分配的存储管理方案。并模拟实现分区的分配和回收过程。 对分区的管理法可以是下面三种算法： 首次适应算法 循环首次...
操作系统实验四主存空间的分配与回收首次适应算法和循环首次适应算法.docx
12-23
操作系统实验四主存空间的分配与回收首次适应算法和循环首次适应算法
操作系统课程设计 循环首次适应算法的动态分区分配方式模拟（c++实现）报告+源代码打包文件
07-05
操作系统课程设计 循环首次适应算法的动态分区分配方式模拟（c++实现）报告+源代码打包文件
动态分区分配内存管理源代码（附有实验报告）最佳适应算法（Best Fit）循环首次适应算法(Next Fit)
06-23
实验题目 设计和实现关于内存管理的内存布局初始化及内存申请分配、内存回收等基本功能操作函数，尝试对用256MB的内存空间进行动态分区方式模拟管理。内存分配的基本单位为1KB，同时要求支持至少两种分配策略，并进行测试和对不同分配策略的性能展开比较评估。 最佳适应算法（Best Fit）： 　　 它从全部空闲区中找出能满足作业要求的、且大小最小的空闲分区，这种方法能使碎片尽量小。为适应此算法，空闲分区表（空闲区链）中的空闲分区要按从小到大进行排序，自表头开始查找到第一个满足要求的自由分区分配。该算法保留大的空闲区，但造成许多小的空闲区。因为它要不断地找出能满足作业要求的、且大小最小的空闲分区，所以比较比较频繁。但是，对内存的利用率高 循环首次适应算法(Next Fit)： 　　 该算法是首次适应算法的变种。在分配内存空间时，不再每次从表头（链首）开始查找，而是从上次找到空闲区的下一个空闲开始查找，直到找到第一个能满足要求的的空闲区为止，并从中划出一块与请求大小相等的内存空间分配给作业。该算法能使内存中的空闲区分布得较均匀。比较次数少于最佳适应算法（Best Fit），内存利用率低于最佳适应算法（Best Fit）。
操作系统“最佳适应算法”代码（c++）
05-07
操作系统“最佳适应算法”代码（c++），课程设计时做的，仅供参考！
操作系统实验 循环首次适应算法（C）
12-01
操作系统中的实验，用C语言实现循环首次适应算法的功能
用C++语言实现首次适应算法
12-18
用C++语言实现操作系统中关于动态空闲空间的分配与回收，用首次适应算法实现。简单的小程序，只用结构体和数组实现。适用于初学者。
首次适应算法的模拟（C++实现）
falldeep的算法世界
10-11 2954
当内存各分区中都无大小大于该作业的可用区时，判断空闲分区总和是否大于该作业的大小，若满足条件，则在紧凑后放入。设置内存总大小为1024KB，进入程序后有四种选项，插入作业请输入1，回收作业请输入0，紧凑请输入2, 查看内存信息请输入3，退出程序请输入4。插入一个名字为jincou的作业，大小为130KB，根据程序运行结果可以发现是经过了紧凑的，说明程序运行正确。此时已经产生了碎片，输入2，进行紧凑操作，程序进行重定位，自动改变了当前内存中作业的起始地址。输入1后，程序可作业进行内存分配。
C 语言模拟首次适应算法
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
05-18 534
C 语言模拟首次适应算法
操作系统首次适应法为作业分配存储空间代码及注释
weixin_54643495的博客
12-29 440
#include <stdio.h> #include <stdlib.h> #define MAX_SIZE 128 //系统分配给用户的最大内存 int a; typedef struct MCB{//内存控制块 int add; //分区起始地址 int sta; //分区状态，0为可用，1为不可用，2不可用且移入回收站 int size; //分区大小 int jno; //分区装入作业号,作业号从...
最佳适应算法 C语言实现
weixin_45761769的博客
12-02 8459
广东工业大学 操作系统实验 用C语言实现采用最佳适应算法的动态分区分配过程和回收过程。 其中，空闲分区通过空闲分区链（表）来管理；在进行内存分配时，系统优先使用空闲区低端的空间，要求每次分配和回收后显示出空闲内存分区链的情况。 #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define FREE 0 #define BUSY 1 #define Max_length 640 typedef s
操作系统【动态分区分配算法——首次适应算法、最佳适应算法、最坏适应算法、临近适应算法】
热门推荐
upward
05-19 4万+
首次适应算法（First Fit）、 最佳适应算法（Best Fit）、 最坏适应算法（Worst Fit）【又称“最大适应算法”（Largest Fit）】、 临近适应算法（Next Fit）
C++ 首次适应算法
最新发布
11-09
C++中的首次适应算法是一种动态空闲空间分配算法，它的主要思想是在内存中找到第一个能够满足作业大小的空闲分区，并将该分区分配给作业。这个算法的实现比较简单，只需要按照空闲分区的起始地址从小到大进行遍历，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值