操作系统实验-磁盘调度算法（3种算法实现）

已于 2023-12-21 19:04:20 修改
阅读量809 收藏 15
点赞数 15
文章标签： c++ 数据结构
于 2023-12-16 03:23:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_65606189/article/details/135027800
版权

（1）选择1-3种磁盘调度算法（先来先服务法、最短寻道优先、电梯算法）模拟实现磁盘调度。

（2）能够输入当前磁头的位置、磁头移动方向、磁道访问请求序列等

（3）计算磁头移动的总磁道数

（4）能够显示磁盘调度结果（依次访问的磁道顺序等）

由于小编实验还未去验收实验，为了以防万一，先贴出效果图，等验收完了就将代码粘贴进来！

刚刚验收完：代码如下

#include<iostream>
#include <fstream>
#include <iomanip>
#include <stdlib.h>
using namespace std;

typedef struct {
    int pSize;
    int id;
}sortResult;

#define MAXNUMBER 100
static int PNum;  //内存中空闲分区的个数
static int FreeProcess[MAXNUMBER];  //空闲分区对应的内存
static int choice;//算法选择
int backchoice;
int rollchoice;
int continuechoice;
int rollsize;
static int SNum; //进程个数
static char SName[MAXNUMBER];//进程名字
static int SNeed[MAXNUMBER];  //进程大小
static char SWhere[MAXNUMBER][MAXNUMBER];//各个进程的分区位置
static int  RWhere[MAXNUMBER][MAXNUMBER];
static int  Rsize[MAXNUMBER][MAXNUMBER];
static int LeftFreeProcess[MAXNUMBER];//分区的剩余大小 
static int LeftSNeed[MAXNUMBER];//进程剩余的大小 

void input();//初始输入
void SelectSolution();
void initial();//初始化
void display();//展示
void firstAdapt();//最先适应法
void bestAdapt();//最佳适应法
void worstAdapt();//最坏适应法
void rolldisplay();//回收


int main() {

    input();
    SelectSolution();
    return 0;
}

//输入分区数和大小、资源数和大小
void input() {
    int i;
    ifstream inData;
    inData.open("dataInput.txt");
    //读取数据
    inData >> PNum;//分区个数
    for (i = 0; i < PNum; i++) {//对应的内存
        inData >> FreeProcess[i];
    }
    inData >> SNum;//进程个数
    for (i = 0; i < SNum; i++) {//初始化名称
        SName[i] = i + 65;
    }

    for (i = 0; i < SNum; i++) {
        inData >> SNeed[i];//进程大小
    }
    cout << "进程名称: " << "\t\t";
    for (i = 0; i < SNum; i++) {
        cout << SName[i] << "\t";
    }
    cout << endl;
    cout << "进程大小： " << "\t\t";
    for (i = 0; i < SNum; i++) {
        cout << SNeed[i] << "\t";
    }
    cout << endl;

    cout << "分区名称: " << "\t\t";
    for (i = 0; i < PNum; i++) {
        cout << "P" << i + 1 << "\t";
    }
    cout << endl << "内存大小: " << "\t\t";
    for (i = 0; i < PNum; i++) {
        cout << FreeProcess[i] << "\t";
    }
}

void SelectSolution() {
    cout << endl << "请选择你需要的算法" << endl;
    cin >> choice;
    if (choice == 1) {
        firstAdapt();
        SelectSolution();
    }
    else if (choice == 2) {
        bestAdapt();
        SelectSolution();
    }
    else if (choice == 3) {
        worstAdapt();
        SelectSolution();
    }
    else {
        cout << "输入格式错误，请重新输入";
        SelectSolution();
    }
}

void initial() {
    int i, j;
    for (int i = 0; i < SNum; i++) {
        for (int j = 0; j < PNum; j++) {
            SWhere[i][j] = NULL;//初始化进程的分区位置
            RWhere[i][j] = 0;
            Rsize[i][j] = 0;
            LeftFreeProcess[j] = FreeProcess[j];//初始化剩余内存分区的大小
        }

    }

    for (i = 0; i < SNum; i++) {
        LeftSNeed[i] = SNeed[i];//初始化进程的剩余的大小
    }
}


void firstAdapt() {
    cout << "最先适应法" << endl;
    initial();
    int i, j;
    for (i = 0; i < SNum; i++) {
        for (j = 0; j < PNum; j++) {
            if (LeftSNeed[i] <= LeftFreeProcess[j] && LeftFreeProcess[j] != 0) {

                int startPosition = 0;
                for (int p = 0; p < j; p++) {
                    startPosition += FreeProcess[p];
                }
                if (LeftFreeProcess[j] < FreeProcess[j]) {
                    startPosition += (FreeProcess[j] - LeftFreeProcess[j]);
                }
                cout << SName[i] << "的起始位置是：" << startPosition << endl;
                LeftFreeProcess[j] -= LeftSNeed[i];
                LeftSNeed[i] = 0;
                SWhere[i][j] = SName[i];//指定进程的位置
                break;
            }
        }
    }
    display();

    cout << "是否进行回收？1.是 2.否" << endl;
    cin >> backchoice;
    int stop = 1;
    if (backchoice == 1) {
        while (stop) {
            rollsize = 0;//每次回收作业要将回收大小初始化
            cout << "请选择你要回收的作业" << endl;
            cin >> rollchoice;
            rollchoice -= 1;
            int mark = 0;
            for (int i = 0; i < PNum; i++) {
                //寻找作业所在的进程
                if (SWhere[rollchoice][i] == SName[rollchoice]) {
                    mark = i;
                    break;
                }
            }
            cout<<"处在进程：" << mark + 1 << endl;
            
            /*如果回收块的上方有空闲-start*/
            int aheadsize = 0;
            for (int j = rollchoice - 1; j >= 0; j--) {
                if (SWhere[j][mark] == SName[j]) {
                    /*说明此时有进程，非空*/
                    break;//寻找结束
                }
                else if (RWhere[j][mark] == 1) {
                    aheadsize += Rsize[j][mark];
                }
                else {
                    continue;
                }
            }
            /*如果回收块的上方有空闲-end*/
            
            /*如果回收块的下方有空闲-start*/
            int abacksize = 0;
            int m;
            for (m = rollchoice + 1; m < SNum; m++) {
                if (SWhere[m][mark] == SName[m]) {
                    break;
                }
                else if (RWhere[m][mark] == 1) {
                    abacksize += Rsize[m][mark];
                }
                else if (RWhere[m][mark] == 2) {
                    abacksize += Rsize[m][mark];
                    break;
                }
                else {
                    continue;
                }
            }
            if (m == SNum) {
                abacksize += LeftFreeProcess[mark]-aheadsize;
                LeftFreeProcess[mark] = 0;
                RWhere[rollchoice][mark] = 2;
            }
            else {
                RWhere[rollchoice][mark] = 1;
            }
            /*如果回收块的下方有空闲-end*/
           
            /*正式回收-start*/
            rollsize = aheadsize + abacksize+SNeed[rollchoice];
            SWhere[rollchoice][mark] = NULL;
            Rsize[rollchoice][mark] = rollsize;

            cout << "回收内存:" << rollsize<<endl;
            /*正式回收-end*/

            /*恢复作业和进程的大小-start*/
            LeftSNeed[rollchoice] = SNeed[rollchoice];
            LeftFreeProcess[mark] += rollsize;
            /*恢复作业和进程的大小-end*/
            rolldisplay();
            cout << "是否继续？1.是 2.否" << endl;
            cin >> continuechoice;
            if (continuechoice == 2) {
                stop = 0;
            }
            else if (continuechoice == 1) {
                stop = 1;
            }
            
        }

    }/*if (backchoice == 1)*/
    
}

void bestAdapt() {
    cout << "最佳适应法" << endl;
    initial();
    int i, j, s, t;
    sortResult bestsort[MAXNUMBER];//用来存取每一个内存区的大小
    sortResult temp;//用来作为交换中介

    for (i = 0; i < PNum; i++) {
        bestsort[i].pSize = LeftFreeProcess[i];
        bestsort[i].id = i;
    }

    for (i = 0; i < SNum; i++) {

        //每一次寻找都是找最接近该进程大小的内存，因此每次循环都得将内存空间进行排序
        //冒泡排序
        for (j = 0; j < PNum - 1; j++) {
            for (t = j; t < PNum; t++) {
                if (bestsort[j].pSize >= bestsort[t].pSize) {
                    temp = bestsort[j];
                    bestsort[j] = bestsort[t];
                    bestsort[t] = temp;
                }
            }
        }

        for (s = 0; s < PNum; s++) {
            if (LeftSNeed[i] <= bestsort[s].pSize) {

                int startPosition = 0;
                for (int p = 0; p < bestsort[s].id; p++) {
                    startPosition += FreeProcess[p];
                }
                if (LeftFreeProcess[bestsort[s].id] < FreeProcess[bestsort[s].id]) {
                    startPosition += (FreeProcess[bestsort[s].id] - LeftFreeProcess[bestsort[s].id]);
                }
                cout << SName[i] << "的起始位置是：" << startPosition << endl;
                bestsort[s].pSize -= LeftSNeed[i];
                LeftSNeed[i] = 0;
                SWhere[i][bestsort[s].id] = SName[i];
                break;
            }
        }


        LeftFreeProcess[bestsort[s].id] = bestsort[s].pSize;

    }
    display();
    cout << "是否进行回收？1.是 2.否" << endl;
    cin >> backchoice;
    int stop = 1;
    if (backchoice == 1) {
        while (stop) {
            rollsize = 0;//每次回收作业要将回收大小初始化
            cout << "请选择你要回收的作业" << endl;
            cin >> rollchoice;
            rollchoice -= 1;
            int mark = 0;
            for (int i = 0; i < PNum; i++) {
                //寻找作业所在的进程
                if (SWhere[rollchoice][i] == SName[rollchoice]) {
                    mark = i;
                    break;
                }
            }
            cout << "处在进程：" << mark + 1 << endl;

            /*如果回收块的上方有空闲-start*/
            int aheadsize = 0;
            for (int j = rollchoice - 1; j >= 0; j--) {
                if (SWhere[j][mark] == SName[j]) {
                    /*说明此时有进程，非空*/
                    break;//寻找结束
                }
                else if (RWhere[j][mark] == 1) {
                    aheadsize += Rsize[j][mark];
                }
                else {
                    continue;
                }
            }
            /*如果回收块的上方有空闲-end*/

            /*如果回收块的下方有空闲-start*/
            int abacksize = 0;
            int m;
            for (m = rollchoice + 1; m < SNum; m++) {
                if (SWhere[m][mark] == SName[m]) {
                    break;
                }
                else if (RWhere[m][mark] == 1) {
                    abacksize += Rsize[m][mark];
                }
                else if (RWhere[m][mark] == 2) {
                    abacksize += Rsize[m][mark];
                    break;
                }
                else {
                    continue;
                }
            }
            if (m == SNum) {
                abacksize += LeftFreeProcess[mark] - aheadsize;
                LeftFreeProcess[mark] = 0;
                RWhere[rollchoice][mark] = 2;
            }
            else {
                RWhere[rollchoice][mark] = 1;
            }
            /*如果回收块的下方有空闲-end*/

            /*正式回收-start*/
            rollsize = aheadsize + abacksize + SNeed[rollchoice];
            SWhere[rollchoice][mark] = NULL;
            Rsize[rollchoice][mark] = rollsize;

            cout << "回收内存:" << rollsize << endl;
            /*正式回收-end*/

            /*恢复作业和进程的大小-start*/
            LeftSNeed[rollchoice] = SNeed[rollchoice];
            LeftFreeProcess[mark] += rollsize;
            /*恢复作业和进程的大小-end*/
            rolldisplay();
            cout << "是否继续？1.是 2.否" << endl;
            cin >> continuechoice;
            if (continuechoice == 2) {
                stop = 0;
            }
            else if (continuechoice == 1) {
                stop = 1;
            }
        }
    }/*if (backchoice == 1)*/

}

void worstAdapt() {
    cout << "最坏适应法" << endl;
    initial();
    int i, j, s, t;
    sortResult worstsort[MAXNUMBER];//用来存取每一个内存区的大小
    sortResult temp;//用来作为交换中介

    for (i = 0; i < PNum; i++) {
        worstsort[i].pSize = LeftFreeProcess[i];
        worstsort[i].id = i;
    }

    for (i = 0; i < SNum; i++) {

        //每一次寻找都是找最接近该进程大小的内存，因此每次循环都得将内存空间进行排序
        //冒泡排序
        for (j = 0; j < PNum - 1; j++) {
            for (t = j; t < PNum; t++) {
                if (worstsort[j].pSize <= worstsort[t].pSize) {
                    temp = worstsort[j];
                    worstsort[j] = worstsort[t];
                    worstsort[t] = temp;
                }
            }
        }

        for (s = 0; s < PNum; s++) {
            if (LeftSNeed[i] <= worstsort[s].pSize) {
                int startPosition = 0;
                for (int p = 0; p < worstsort[s].id; p++) {
                    startPosition += FreeProcess[p];
                }
                if (LeftFreeProcess[worstsort[s].id] < FreeProcess[worstsort[s].id]) {
                    startPosition += (FreeProcess[worstsort[s].id] - LeftFreeProcess[worstsort[s].id]);
                }
                cout << SName[i] << "的起始位置是：" << startPosition << endl;

                worstsort[s].pSize -= LeftSNeed[i];
                LeftSNeed[i] = 0;
                SWhere[i][worstsort[s].id] = SName[i];
                break;
            }
        }

        if (s < PNum) {
            LeftFreeProcess[worstsort[s].id] = worstsort[s].pSize;
        }

    }
    display();
    cout << "是否进行回收？1.是 2.否" << endl;
    cin >> backchoice;
    int stop = 1;
    if (backchoice == 1) {
        while (stop) {
            rollsize = 0;//每次回收作业要将回收大小初始化
            cout << "请选择你要回收的作业" << endl;
            cin >> rollchoice;
            rollchoice -= 1;
            int mark = 0;
            for (int i = 0; i < PNum; i++) {
                //寻找作业所在的进程
                if (SWhere[rollchoice][i] == SName[rollchoice]) {
                    mark = i;
                    break;
                }
            }
            cout << "处在进程：" << mark + 1 << endl;

            /*如果回收块的上方有空闲-start*/
            int aheadsize = 0;
            for (int j = rollchoice - 1; j >= 0; j--) {
                if (SWhere[j][mark] == SName[j]) {
                    /*说明此时有进程，非空*/
                    break;//寻找结束
                }
                else if (RWhere[j][mark] == 1) {
                    aheadsize += Rsize[j][mark];
                }
                else {
                    continue;
                }
            }
            /*如果回收块的上方有空闲-end*/

            /*如果回收块的下方有空闲-start*/
            int abacksize = 0;
            int m;
            for (m = rollchoice + 1; m < SNum; m++) {
                if (SWhere[m][mark] == SName[m]) {
                    break;
                }
                else if (RWhere[m][mark] == 1) {
                    abacksize += Rsize[m][mark];
                }
                else if (RWhere[m][mark] == 2) {
                    abacksize += Rsize[m][mark];
                    break;
                }
                else {
                    continue;
                }
            }
            if (m == SNum) {
                abacksize += LeftFreeProcess[mark] - aheadsize;
                LeftFreeProcess[mark] = 0;
                RWhere[rollchoice][mark] = 2;
            }
            else {
                RWhere[rollchoice][mark] = 1;
            }
            /*如果回收块的下方有空闲-end*/

            /*正式回收-start*/
            rollsize = aheadsize + abacksize + SNeed[rollchoice];
            SWhere[rollchoice][mark] = NULL;
            Rsize[rollchoice][mark] = rollsize;

            cout << "回收内存:" << rollsize << endl;
            /*正式回收-end*/

            /*恢复作业和进程的大小-start*/
            LeftSNeed[rollchoice] = SNeed[rollchoice];
            LeftFreeProcess[mark] += rollsize;
            /*恢复作业和进程的大小-end*/
            rolldisplay();
            cout << "是否继续？1.是 2.否" << endl;
            cin >> continuechoice;
            if (continuechoice == 2) {
                stop = 0;
            }
            else if (continuechoice == 1) {
                stop = 1;
            }
        }
    }/*if (backchoice == 1)*/
}

//显示分区结果
void display() {
    int i;
    cout << endl;
    cout << "进程名称: " << "\t\t";
    for (i = 0; i < SNum; i++) {
        cout << SName[i] << "\t";
    }
    cout << endl;
    cout << "进程大小： " << "\t\t";
    for (i = 0; i < SNum; i++) {
        cout << SNeed[i] << "\t";
    }
    cout << endl;

    cout << "分区名称: " << "\t\t";
    for (i = 0; i < PNum; i++) {
        cout << "P" << i + 1 << "\t";
    }
    cout << endl << "内存大小: " << "\t\t";
    for (i = 0; i < PNum; i++) {
        cout << FreeProcess[i] << "\t";
    }
    cout << endl << "分区剩余内存大小: " << "\t";
    for (i = 0; i < PNum; i++) {
        cout << LeftFreeProcess[i] << "\t";
    }
    cout << endl << "分区结果:" << endl;
   

    for (i = 0; i < SNum; i++) {
        bool find = false;
        for (int j = 0; j < PNum; j++) {
            if (SWhere[i][j] != NULL) {
                find = true;
                cout << SWhere[i][j] << ":P" << j + 1 << endl;
            }
        }
        if (!find) {
            cout << SName[i] << ":没有合适的内存P?"<<endl;
        }
    }
}

void rolldisplay() {
    int i;
    cout << endl;
    cout << "进程名称: " << "\t\t";
    for (i = 0; i < SNum; i++) {
        cout << SName[i] << "\t";
    }
    cout << endl;
    cout << "进程大小： " << "\t\t";
    for (i = 0; i < SNum; i++) {
        cout << SNeed[i] << "\t";
    }
    cout << endl;

    cout << "分区名称: " << "\t\t";
    for (i = 0; i < PNum; i++) {
        cout << "P" << i + 1 << "\t";
    }
    cout << endl << "内存大小: " << "\t\t";
    for (i = 0; i < PNum; i++) {
        cout << FreeProcess[i] << "\t";
    }
    cout << endl << "分区剩余内存大小: " << "\t";
    for (i = 0; i < PNum; i++) {
        cout << LeftFreeProcess[i] << "\t";
    }
    cout << endl << "分区结果:" << endl;
   

    for (i = 0; i < SNum; i++) {
        bool find = false;
        for (int j = 0; j < PNum; j++) {
            if (SWhere[i][j] != NULL) {
                find = true;
                cout << SWhere[i][j] << ":P" << j + 1 << endl;
            }
        }
        if (!find) {
            cout << SName[i] << ":已经被回收" << endl;
        }
    }
}

①先来先服务算法

②最短寻道算法

③扫描算法（scan）-向前、向后

老规矩，点赞破十放代码！

小羊驼爱摆烂
关注
  • 15
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值