张欣阳永远永远

m0_73378175

已于 2023-12-14 16:38:59 修改

阅读量23

点赞数

文章标签：算法

于 2023-11-16 16:55:50 首次发布

本文链接：https://blog.csdn.net/m0_73378175/article/details/134446035

版权

#include <stdio.h>
#include <stdlib.h>
 
void CopyL(int Sour[],int Dist[] ,int x); //数组Sour复制到数组Dist，复制到x个数
void SetDI(int DiscL[]);  //随机生成磁道数
void Print(int Pri[],int x);  //打印输出数组Pri
void DelInq(int Sour[],int x,int y);  //数组Sour把x位置的数删除，并把y前面的数向前移动，y后的数保持不变(即会出现2个y)
void FCFS(int Han,int DiscL[]);  //先来先服务算法(FCFS)
void SSTF(int Han,int DiscL[]);  //最短寻道时间优先算法(SSTF)
int SCAN(int Han,int DiscL[],int x,int y);  //扫描算法(SCAN)
void CSCAN(int Han,int DiscL[]);  //循环扫描算法(CSCAN)
void N_Step_SCAN(int Han1,int DiscL[]);  //N步扫描算法(NStepScan)
void PaiXu();  //寻道长度由低到高排序
void Pri();
int NAll=0;
int Best[5][2]; //用作寻道长度由低到高排序时存放的数组
int Limit=0; //输入寻找的范围磁道数i
int Jage;
float Aver=0;
 
int main()
{
    int i;
    int DiscLine[10];  //声明准备要生成的随机磁道号的数组
    int Hand;  //磁道数
    int Con=1;
    int n;
    while(Con==1)
    {
        Jage=0;
        printf(" 请输入初始的磁道数(0<n<65536):");
        scanf("%d",&Hand);
        printf(" + 输入寻找的范围:");
        scanf("%d",&Limit);
        if(Limit<=0||Limit>65536){
            printf("超出范围!");
        }
        else{
            printf("             ╭═══════════════╮             \n");
            printf("             ║       操作系统课程实验       ║             \n");
            printf(" ╭═════┤         磁盘调度算法         ├═════╮ \n");
            printf(" ║          ║                              ║          ║ \n");
            printf(" ║          ╰═══════════════╯          ║ \n");
            printf(" ║               1.先来先服务算法(FCFS)                 ║ \n");
            printf(" ║                                                      ║ \n");
            printf(" ║               2.最短寻道时间优先算法(SSTF)           ║ \n");
            printf(" ║                                                      ║ \n");
            printf(" ║               3.扫描算法(SCAN)                       ║ \n");
            printf(" ║                                                      ║ \n");
            printf(" ║               4.循环扫描算法(CSCAN)                  ║ \n");
            printf(" ║                                                      ║ \n");
            printf(" ║                                                      ║ \n");
            printf(" ║  ╭───────────────────────╮  ║ \n");
            printf(" ╰═┤        请输入你的选择的算法(输入0离开)       ├═╯ \n");
            printf("     ╰───────────────────────╯     \n");
            scanf("%d",&n);
            if(n==0) exit(0);
            printf(" ");
            switch(n)
            {
            case 1:
                SetDI(DiscLine);  //随机生成磁道数
                FCFS(Hand,DiscLine); //先来先服务算法(FCFS)
                break;
            case 2:
                SetDI(DiscLine);  //随机生成磁道数
                SSTF(Hand,DiscLine); //最短寻道时间优先算法(SSTF)
                break;
            case 3:
                SetDI(DiscLine);  //随机生成磁道数
                SCAN(Hand,DiscLine,0,9);  //扫描算法(SCAN)
                break;
            case 4:
                SetDI(DiscLine);  //随机生成磁道数
                CSCAN(Hand,DiscLine); //循环扫描算法(CSCAN)
                break;
            }
            printf(" + 是否继续(按0结束,按1继续)?");
            scanf("%5d",&Con);
        }
 
    }
}
 
//数组Sour复制到数组Dist，复制到x个数
void CopyL(int Sour[],int Dist[] ,int x)
{
    int i;
    for(i=0;i<=x;i++)
    {
        Dist[i]=Sour[i];
    }
}
//打印输出数组Pri
void Print(int Pri[],int x)
{
    int i;
    for(i=0;i<=x;i++)
    {
        printf("%5d",Pri[i]);
    }
}
//随机生成磁道数
void SetDI(int DiscL[])
{
    int i;
    for(i=0;i<=9;i++)
    {
        DiscL[i]=rand()%Limit;//随机生成10个磁道号
    }
    printf("+ 需要寻找的磁道号:");
    Print(DiscL,9);  //输出随机生成的磁道号
    printf(" \n");
}
//数组Sour把x位置的数删除，并把y前面的数向前移动，y后的数保持不变(即会出现2个y)
void DelInq(int Sour[],int x,int y)
{
    int i;
    for(i=x;i<y;i++)
    {
        Sour[i]=Sour[i+1];
        x++;
    }
}
//先来先服务算法(FCFS)
void FCFS(int Han,int DiscL[])
{
    int RLine[10];  //将随机生成的磁道数数组Discl[]复制给数组RLine[]
    int i,k,All,Temp;  //Temp是计算移动的磁道距离的临时变量
    All=0;  //统计全部的磁道数变量
    k=9;  //限定10个的磁道数
    CopyL(DiscL,RLine,9);  //复制磁道号到临时数组RLine
    printf(" + 按照FCFS算法磁道的访问顺序为:");
    All=Han-RLine[0];
    for(i=0;i<=9;i++)
    {
        Temp=RLine[0]-RLine[1];//求出移动磁道数,前一个磁道数减去后一个磁道数得出临时的移动距离
        if(Temp<0)
            Temp=(-Temp);//移动磁道数为负数时,算出相反数作为移动磁道数
        printf("%5d",RLine[0]);
        All=Temp+All;//求全部磁道数的总和
        DelInq(RLine,0,k);//每个磁道数向前移动一位
        k--;
    }
    Best[Jage][1]=All;//Best[][1]存放移动磁道数
    Best[Jage][0]=1; //Best[][0]存放算法的序号为:1
    Jage++;//排序的序号加1
    Aver=((float) All)/10;//求平均寻道次数
    printf("\n");
    printf(" + 移动磁道数:<%5d> ",All);printf("\n");
    printf(" + 平均寻道长度:*%0.2f* \n",Aver);printf("\n");
}
 
//冒泡排序
int* Bubble(int pArr[],int nFirst,int nEnd)
{
    int nTemp=0;
    for(int i=nFirst;i<nEnd;++i)
    {
        for(int j=i;j<nEnd;++j)
        {
            if(pArr[i]>pArr[j])
            {
                nTemp=pArr[i];
                pArr[i]=pArr[j];
                pArr[j]=nTemp;
            }
        }
    }
    return pArr;
}
 
//最短寻道时间优先算法(SSTF)
void SSTF(int Han,int DiscL[])
{
    int temp;
    int k=1,n=10;
    int l,r;
    int i,j,all=0;
 
    //将磁道号按递增排序
    DiscL=Bubble(DiscL,0,10);
 
    printf("\n+ 按照SSTF算法磁道的访问顺序为:：");
 
    //判断标志位Han左、右两边的偏移量大小
    if(DiscL[n-1]<=Han)//当前磁头位置大于最外围欲访问磁道
    {
      for(i=n-1;i>=0;i--)
      {
          printf("%d  ",DiscL[i]);
      }
      all=Han-DiscL[0];
    }
    else
      if(DiscL[0]>=Han)//当前磁头位置小于最里欲访问磁道
      {
          for(i=0;i<n;i++)
          {
              printf("%d  ",DiscL[i]);
          }
          all=DiscL[n-1]-Han;
      }
    else
    {
        while(DiscL[k]<Han)//确定当前磁道在已排的序列中的位置
        {
          k++;
        }
         l=k-1;//在磁头位置的前一个欲访问磁道
         r=k;//磁头欲访问磁道
 
        while((l>=0)&&(r<n))
        {
         if((Han-DiscL[l])<=(DiscL[r]-Han))//选择离磁头近的磁道
         {
             printf("%d  ",DiscL[l]);
             all+=Han-DiscL[l];
             Han=DiscL[l];
             l=l-1;
         }
        else
        {
            printf("%d  ",DiscL[r]);
            all+=DiscL[r]-Han;
            Han=DiscL[r];
            r=r+1;
        }
      }
      if(l=-1)//磁头位置里侧的磁道已访问完
      {
         for(j=r;j<n;j++)//访问磁头位置外侧的磁道
         {
            printf("%d  ",DiscL[j]);
         }
             all+=DiscL[n-1]-DiscL[0];
      }
    if(r==n)//磁头位置外侧的磁道已访问完
    {
    for(j=k-1;j>-1;j--) //访问磁头位置里侧的磁道
      {
          printf("%d  ",DiscL[j]);
      }
          all+=DiscL[n-1]-DiscL[0];
     }
 }
      printf("\n + 移动磁道数:<%5d> \n",all);
      printf(" + 平均寻道长度:*%0.2f* \n",all/10.0);
 
}
 
//扫描算法(SCAN)
int SCAN(int Han,int DiscL[],int x,int y)
{
    int temp;
    int k=1,n=10;
    int l,r;
    int i,j,all=0;
    DiscL=Bubble(DiscL,x,y);
    //printf("按递增顺序排好的磁道为：");
    //for( i=0;i<n;i++)
    //{
    //  printf("%d ",DiscL[i]);
    //}
 
    //以下算法确定磁道访问顺序
     if(DiscL[n-1]<=Han) //磁头位置大于最外围欲访问磁道
       {
           for(i=n-1;i>=0;i--)
             printf("%d ",DiscL[i]);
           all=Han-DiscL[0];
       }
       else
           if(DiscL[0]>=Han) //磁头位置小于最里欲访问磁道
           {
              for(i=0;i<n;i++)
                 printf("%d ",DiscL[i]);
              all=DiscL[n-1]-Han;
           }
           else                   //磁头位置在最里侧磁道与最外侧磁道之间
           {   int d;
               while(DiscL[k]<Han)
               {             //确定当前磁道在已排的序列中的位置
                   k++;
               }
               l=k-1;//在磁头位置的前一个欲访问磁道
               r=k;   //磁头欲访问磁道
               printf("\n请输入当前磁头移动的方向 (0 表示向内 ，1表示向外) : ");
               scanf("%d",&d);  //确定磁头访问的方向
 
               printf("按照SCAN算法访问顺序为：");
               if(d==0||d==1)
               {
                      if(d==0)    //磁头向内
                      {
                        for(j=l;j>=0;j--)
                        {
                             printf("%d ",DiscL[j]);
                        }
                        for(j=r;j<n;j++)
                        {
                            printf("%d ",DiscL[j]);
                        }
                         all=Han-2*DiscL[0]+DiscL[n-1];
                      }
                        if(d==1)               //磁头向外
                        {
                            for(j=r;j<n;j++)
                            {
                                printf("%d ",DiscL[j]);
                            }
                            for(j=l;j>=0;j--)
                            {
                                printf("%d ",DiscL[j]);
                            }
                             all=2*DiscL[n-1]-Han-DiscL[0];
                        }
               }
            else
                printf("请输入0或1！");
            }
 
      printf("\n + 移动磁道数:<%5d> \n",all);
      printf(" + 平均寻道长度:*%0.2f* \n",all/10.0);
      return 0;
}
//循环扫描算法(CSCAN)
void CSCAN(int Han,int DiscL[])
{
    int temp;
    int    l,r;
    int i,j,all=0;
    int k=1,n=10;
    //对访问磁道按由小到大顺序排列输出
    DiscL=Bubble(DiscL,0,10);
    //printf("按递增顺序排好的磁道为：");
    //for( i=0;i<n;i++)
    //{
    //  printf("%d ",DiscL[i]);
    //}
 
    if(DiscL[n-1]<=Han)//磁头位置大于最外围欲访问磁道
    {
      for(i=0;i<n;i++)
            printf("%d ",DiscL[i]);
            all=Han-2*DiscL[0]+DiscL[n-1];
        }
        else
            if(DiscL[0]>=Han)//磁头位置小于最里欲访问磁道
            {
                for(i=0;i<n;i++)
                    printf("%d ",DiscL[i]);
                all=DiscL[n-1]-Han;
            }
            else //磁头位置在最里侧磁道与最外侧磁道之间
            {    int d;
                while(DiscL[k]<Han)
                {
                    k++;
                }
               l=k-1;//在磁头位置的前一个欲访问磁道
               r=k;   //磁头欲访问磁道
               printf("\n请输入当前磁头移动的方向 (0 表示向内 ，1表示向外) : ");
               scanf("%d",&d);  //确定磁头访问的方向
               printf("按照CSCAN算法访问顺序为：");
               if(d==0||d==1)
               {
                   if(d==1)    //磁头向外侧访问
                   {
                    for(j=r;j<n;j++)//先访问外侧磁道再转向最里欲访问磁道
                    {
                         printf("%d ",DiscL[j]);
                    }
                    for(j=0;j<r;j++)
                    {
                        printf("%d ",DiscL[j]);
                    }
                     all=2*DiscL[n-1]-Han-2*DiscL[0]+DiscL[l];
                   }
                  if(d==0)                //磁头向内侧访问
                  {
                     for(j=r-1;j>=0;j--)
                     {
                        printf("%d ",DiscL[j]);
                     }
                     for(j=n-1;j>=r;j--)
                     {
                        printf("%d ",DiscL[j]);
                     }
                     all=2*DiscL[n-1]-2*DiscL[0]+Han-DiscL[r];
                  }
               }
              else
                printf("请输入0或1!");
           }
 
      printf("\n + 移动磁道数:<%5d> \n",all);
      printf(" + 平均寻道长度:*%0.2f* \n",all/10.0);
}

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

// 定义进程和资源的数量
#define P 5 // 进程数
#define R 3 // 资源数

// 初始化可用资源
int available[R] = {3, 3, 2};

// 最大需求矩阵
int maximum[P][R] = {
{7, 5, 3},
{3, 2, 2},
{9, 0, 2},
{2, 2, 2},
{4, 3, 3}
};

// 分配矩阵
int allocation[P][R] = {
{0, 1, 0},
{2, 0, 0},
{3, 0, 2},
{2, 1, 1},
{0, 0, 2}
};

// 需求矩阵
int need[P][R];

// 打印矩阵的函数原型
void printMatrix(int matrix[P][R], char *name);

// 检查是否有足够的资源分配给进程
int isSafe() {
// 初始化工作向量
int work[R];
for (int i = 0; i < R; ++i) {
work[i] = available[i];
}

// 初始化完成标志数组
int finish[P];
for (int i = 0; i < P; ++i) {
finish[i] = 0;
}

// 安全性检查
int safe = 1;
while (safe) {
safe = 0;
for (int i = 0; i < P; ++i) {
if (!finish[i]) {
int j;
for (j = 0; j < R; ++j) {
if (need[i][j] > work[j]) {
break;
}
}

if (j == R) {
// 进程可以完成
for (int k = 0; k < R; ++k) {
work[k] += allocation[i][k];
}
finish[i] = 1;
safe = 1;
}
}
}
}

// 检查是否所有进程都完成
for (int i = 0; i < P; ++i) {
if (!finish[i]) {
return 0; // 有进程无法完成，不安全
}
}

return 1; // 所有进程都能完成，安全
}

// 检查是否有足够的资源分配给进程
int isSafe(int process, int request[]) {
// 检查请求是否小于等于需要的资源
for (int i = 0; i < R; ++i) {
if (request[i] > need[process][i] || request[i] > available[i]) {
return 0; // 请求资源超过了需要或者超过了可用资源，不安全
}
}

// 尝试分配资源给进程
for (int i = 0; i < R; ++i) {
available[i] -= request[i];
allocation[process][i] += request[i];
need[process][i] -= request[i];
}

// 检查分配后系统是否仍然是安全的
if (isSafe()) {
return 1; // 安全
} else {
// 回滚分配
for (int i = 0; i < R; ++i) {
available[i] += request[i];
allocation[process][i] -= request[i];
need[process][i] += request[i];
}
return 0; // 不安全
}
}

// 打印矩阵的函数定义
void printMatrix(int matrix[P][R], char *name) {
printf("%s:\n", name);
for (int i = 0; i < P; ++i) {
for (int j = 0; j < R; ++j) {
printf("%d ", matrix[i][j]);
}
printf("\n");
}
printf("\n");
}

// 主函数
int main() {
// 计算需求矩阵
for (int i = 0; i < P; ++i) {
for (int j = 0; j < R; ++j) {
need[i][j] = maximum[i][j] - allocation[i][j];
}
}

// 打印初始矩阵
printMatrix(maximum, "Maximum");
printMatrix(allocation, "Allocation");
printMatrix(need, "Need");
printMatrix(available, "Available");

// 在这里进行资源请求和安全性检查
// 示例：请求资源给进程0
int process = 0;
int request[R] = {0, 1, 0};

if (isSafe(process, request)) {
printf("资源分配安全\n");
} else {
printf("资源分配不安全\n");
}

return 0;
}

m0_73378175

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
张欣阳永远永远

/ 请求资源超过了需要或者超过了可用资源，不安全。// 有进程无法完成，不安全。// 所有进程都能完成，安全。// 检查请求是否小于等于需要的资源。// 检查分配后系统是否仍然是安全的。// 在这里进行资源请求和安全性检查。#define P 5 // 进程数。#define R 3 // 资源数。// 检查是否有足够的资源分配给进程。// 检查是否所有进程都完成。// 检查是否有足够的资源分配给进程。// 示例：请求资源给进程0。// 初始化完成标志数组。// 尝试分配资源给进程。
复制链接

扫一扫