課程設計題目與內(nèi)容
題目：采用五個算法，各自作業(yè)在1024kB空間上分配情況。
內(nèi)存可變分區(qū)分配仿真算法：首次適應，下次適應，最佳適應，最壞適應和快速分配。
使用的結構體數(shù)組表示起始地址，內(nèi)存塊大小，內(nèi)存塊狀態(tài)（0空閑，1占用）
#include <stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#define L 10 //宏定義，即把N的值定義為10
struct Info
{
int startadress;
int size;
int state;
};
typedef struct Lnode{ //定義了一個Lnode結構體，其中包括起始地址，大小，狀態(tài);i
int startaddress; //起始地址
int size; //內(nèi)存塊大小
int state; //內(nèi)存塊狀態(tài)
}LNode; // typedef把struct Lnode這個結構體類型名字重新定義為Lnode
LNode P[L]={{0,100,0},{100,200,0},{300,300,0},{600,400,0}}; //
LNode K[L]={{0,100,0},{100,200,0},{300,300,0},{600,400,0}}; //定義兩個是為了最壞適應算法
int N=4; //定義N的起始值為4void bubbleprint(struct Info info[])函數(shù)是為了內(nèi)存塊大小從小到大排序，就可以用循環(huán)的方法更好地查找到作業(yè)所需要的內(nèi)存大小。也為了輸出屏幕看到的內(nèi)存數(shù)列有序。
void print()函數(shù)就是打印當前內(nèi)存分配情況。
void bubbleprint(struct Info info[]) //內(nèi)存從小到大排序，就可以用循環(huán)的方法
{
int i,s;
Info a[1];
for(i=0;i<21;i++)
{
for(s=0;s<21-i;s++)
{
if(info[s].startadress>info[s+1].startadress&&s<20)
{
a[0]=info[s];
info[s]=info[s+1];
info[s+1]=a[0];
}
}
}
printf("Startaddress\tsize\tstate\n");
for(i=0;i<21;i++)
{
if(info[i].size!=0)
{
printf("%3d\t %8d\t%4d\n",info[i].startadress,info[i].size,info[i].state);
}
}
}
void print()
{ //定義一個print()函數(shù)，打印空間狀態(tài)
int i ,size;
LNode j[10];int s=0;
for(i=0;i<N;i++)
{
for(s=0;s<N-i;s++)
{
if(P[s].startaddress>P[s+1].startaddress&&s<N-1)
{
j[0]=P[s];
P[s]=P[s+1];
P[s+1]=j[0];
}
}
}
for(i=0;i<N;i++)
{
int x=0;
printf("%d",P[i].startaddress);
for(size=P[i].size;size>0;size=size-100)
{
if( P[i].state == 1)
{
x+=1;
printf("\t1111111111\t已占用\n");
}
else
printf("\t~~~~~~~~~~\n");
}
}
printf("Startaddress\tsize\tstate\n"); //在屏幕上打印Startaddress size state并換行
for(i=0;i<N;i++) //用for循環(huán)，顯示內(nèi)存塊的分配狀況
{
printf("%3d\t %8d\t%4d\n",P[i].startaddress,P[i].size,P[i].state);
}
}算法原理
首次適應分配算法
最先適應(first fit)分配算法。該算法順序查找未分配區(qū)表或鏈表，直至找到第一個能滿足長度要求的空閑區(qū)為止，分割此分區(qū)，一部分分配給作業(yè)，另一部分仍為空閑區(qū)(若有)。采用這一分配算法時，未分配區(qū)表或鏈表中的空閑區(qū)通常按地址從小到大排列。這樣，為進程分配內(nèi)存空間時從低地址部分的空閑區(qū)開始查找，可使高地址部分盡可能少用，以保持一個大空閑區(qū)，有利于大作業(yè)裝入；但這樣做會使內(nèi)存低地址和高地址兩端的分區(qū)利用不均衡，也將給回收分區(qū)帶來麻煩，需要搜索未分配區(qū)表或鏈表來確定它在表格或鏈表中的位置且要移動相應登記項。
優(yōu)點：優(yōu)先利用內(nèi)存中低址部分的空閑分區(qū)，從而保留了高址部分的大空閑區(qū)，這為以后到達的大作業(yè)分配大的內(nèi)存空間創(chuàng)造了條件。
缺點：低址部分不斷被劃分，會留下許多難以利用的，很小的空閑分區(qū)，稱為碎片。而每次查找又都是從低址部分開始的，這無疑又會增加查找可用空閑分區(qū)時的開銷。
以下是首次適應算法函數(shù)：
void First(){ //定義一個FirstO函數(shù){
int i,l=0,m; //li用于循環(huán)內(nèi)存塊的塊數(shù);1為標識符，用于顯示分配成功; m為要分配的內(nèi)存大小
printf("Please input the memory size:");
scanf("%d",&m); //輸入要分配的內(nèi)存大小
for(i=0;i<N;i++) //用循環(huán)依次尋找內(nèi)存塊的大小是否滿足輸入要分配的內(nèi)存大小{/遍歷是否滿足內(nèi)存塊的大小大于所輸入的要分配的內(nèi)存大小
{
if(P[i].size<m) continue; //如果小于的話，跳到下一次的循環(huán);直到找到大于等于為止，不然就退出該循環(huán)
else if (P[i].size==m&&P[i].state!=1){ //如果內(nèi)存塊的大小等于所輸入要分配的內(nèi)存大小，則將
P[i].state=1; //該塊的內(nèi)存塊的狀態(tài)修改為1;
l=1;
break; //退出循環(huán)，直接跳到if (1==1||i<N）處
}
else if(P[i].size>m&&P[i].state!=1) //如果該內(nèi)存塊的大小大于所輸入要分配的內(nèi)存大小
{
P[N].startaddress=P[i].startaddress+m; //該內(nèi)存塊的起始地址與要輸入的分配的內(nèi)存塊天小之和的值賦予N塊的起始地址
P[N].size=P[i].size-m; //該內(nèi)存塊的起始地址減去要輸入的分配的內(nèi)存塊大小所得的值賦N塊的內(nèi)存夫小
P[i].size=m; //把所輸入的分配的內(nèi)存塊大小的值賦給該塊的內(nèi)存大小
P[i].state=1; //該塊的內(nèi)存塊狀態(tài)設置為1
l=1; //l設置為1
N++; //將N個地址塊變?yōu)镹+1個地址塊的塊號
break; //退出循環(huán)，直接跳到if (1==1||i<N）處
}
}
if(l==1||i<N) //如果
{
printf("Address allocate successful\n\n");
printf("state!!!!!!!!!!\n");
print();
}
else printf("No used memory space!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
}下次適應分配算法
下次適應(next fit)分配算法。該算法總是從未分配區(qū)的上次掃描結束處順序查找未分配區(qū)表或鏈表，直至找到第一個能滿足長度要求的空閑區(qū)為止，分割這個未分配區(qū)，一部分分配給作業(yè)，另一部分仍為空閑區(qū)(若有)。這一算法是最先適應分配算法的變種，能夠縮短平均查找時間，且存儲空間利用率更加均衡，不會導致小空閑區(qū)集中于內(nèi)存一端。
特點：能使內(nèi)存中的空閑區(qū)分布得較均勻。
以下是下次適應分配算法函數(shù)：
void Next()
{
int i=0,t=0,l=0,m,s,n;
LNode j[10],Max[1]={0,0,0};
printf("\n Plase input the size\n");
scanf("%d",&n);
m=n;
for(i=0;i<N;i++) //找出最大的內(nèi)存的容量
{
if(Max[0].size<K[i].size)
Max[0].size=K[i].size;
}
for(i=0;i<N;i++)
{
if(K[i].size<m)
{
if(K[i].state==0&&Max[0].size>m)
{
for(int x=i;x<N-1;x++) //把狀態(tài)為0的內(nèi)存后移
{
j[0]=K[x];
K[x]=K[x+1];
K[x+1]=j[0];
}
i--;
}
else continue;
}
else if(K[i].size==m&&K[i].state!=1)
{
K[i].state=1; //該塊的內(nèi)存塊的狀態(tài)修改為1;
l=1;
break;
}
else if(K[i].size>m&&K[i].state!=1)
{
K[N].startaddress=K[i].startaddress+m; //該內(nèi)存塊的起始地址與要輸入的分配的內(nèi)存塊天小之和的值賦予N塊的起始地址
K[N].size=K[i].size-m; //該內(nèi)存塊的起始地址減去要輸入的分配的內(nèi)存塊大小所得的值賦N塊的內(nèi)存夫小
K[N].state=0;
K[i].size=m; //把所輸入的分配的內(nèi)存塊大小的值賦給該塊的內(nèi)存大小
K[i].state=1; //該塊的內(nèi)存塊狀態(tài)設置為1
l=1; //l設置為1
N++; //將N個地址塊變?yōu)镹+1個地址塊的塊號
for(int min=N-1;min>i+1;min--)
{
j[0]=K[min];
K[min]=K[min-1];
K[min-1]=j[0];
}
break;
}
}
if(l==1||i<N) //如果
{
printf("Address allocate successful\n\n");
printf("state!!!!!!!!!!\n");
}
else printf("No used memory space!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
memcpy(P,K,sizeof(K));
}最優(yōu)適應分配算法
最優(yōu)適應(best fit)分配算法。該算法掃描整個未分配區(qū)表或鏈表，從空閑區(qū)中挑選一個能滿足用戶進程要求的最小分區(qū)進行分配。此算法保證不會分割一個更大的區(qū)域，使得裝入大作業(yè)的要求容易得到滿足，同時，通常把空閑區(qū)按長度遞增順序排列，查找時總是從最小一個空閑區(qū)開始，直至找到滿足要求的分區(qū)為止，這時最優(yōu)適應分配算法等同于最先適應分配算法。此算法的內(nèi)存利用率好，所找出的分區(qū)如果正好滿足要求則是最合適的；如果比所要求的分區(qū)略大則分割后會使剩下的空閑區(qū)很小，難以利用，其查找時間也是最長的。
優(yōu)點：每次分配給文件的都是最合適該文件大小的分區(qū)。
缺點：內(nèi)存中留下許多難以利用的小的空閑區(qū)（外碎片）
以下是最優(yōu)適應算法函數(shù)：
void Best()
{
int i,t=0,l=0,m,s;
LNode j[10],a[10];
printf("\n Plase input the size\n");
scanf("%d",&m);
for(i=0;i<N;i++)
{
j[i]=P[i];
}
for(i=0;i<N;i++)
{
for(s=0;s<N-i;s++)
{
if(j[s].size>j[s+1].size&&s<N-1)
{
a[0]=j[s];
j[s]=j[s+1];
j[s+1]=a[0];
}
}
}
for(i=0;i<N;i++)
{
if(j[i].size<m)
continue;
else if(j[i].size>=m&&j[i].state!=1)
{
j[i].state=1;
for(int p=0;p<N;p++)
{
if(P[p].startaddress==j[i].startaddress)
P[p].state=1;
}
if(j[i].size>m)
{
P[N].startaddress=j[i].startaddress+m; //該內(nèi)存塊的起始地址與要輸入的分配的內(nèi)存塊天小之和的值賦予N塊的起始地址
P[N].size=j[i].size-m; //該內(nèi)存塊的起始地址減去要輸入的分配的內(nèi)存塊大小所得的值賦N塊的內(nèi)存夫小
j[i].size=m; //把所輸入的分配的內(nèi)存塊大小的值賦給該塊的內(nèi)存大小
for(int p=0;p<N;p++)
{
if(P[p].startaddress==j[i].startaddress)
P[p].size=m;
}
l=1; //l設置為1
N++; //將N個地址塊變?yōu)镹+1個地址塊的塊號
}
l=1;
break;
}
}
if(l==1||i<N)
{
printf("Address allocate successful\n\n");
printf("state!!!!!!!!!!\n");
}
else printf("No used memory space!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
}
最壞適應分配算法
最壞適應(worst fit)分配算法。該算法掃描整個未分配區(qū)表或鏈表，總是挑選一個最大的空閑區(qū)分割給作業(yè)使用，其優(yōu)點是使剩下的空閑區(qū)不致過小，對中小型作業(yè)有利。采用此分配算法可把空閑區(qū)按長度遞減順序排列，查找時只需看第一個分區(qū)能否滿足進程要求，這樣使最壞適應分配算法的查找效率很高，此時，最壞適應分配算法等同于最先適應分配算法。
特點：盡可能的分配大的分區(qū)。
缺點：使得內(nèi)存缺乏大分區(qū)，可能使得后續(xù)到來的大作業(yè)無法裝入內(nèi)存。
以下是最壞適應算法函數(shù)：
void Worst()
{
int i,t=0,l=0,m,s;
LNode j[10],a[10];
printf("\n Plase input the size\n");
scanf("%d",&m);
for(i=0;i<N;i++)
{
j[i]=P[i];
}
for(i=0;i<N;i++)
{
for(s=0;s<N-i;s++)
{
if(j[s].size<j[s+1].size&&s<N-1)
{
a[0]=j[s];
j[s]=j[s+1];
j[s+1]=a[0];
}
}
}
for(i=0;i<N;i++)
{
if(j[i].size<m)
continue;
else if(j[i].size>=m&&j[i].state!=1)
{
j[i].state=1;
for(int p=0;p<N;p++)
{
if(P[p].startaddress==j[i].startaddress)
P[p].state=1;
}
if(j[i].size>m)
{
P[N].startaddress=j[i].startaddress+m; //該內(nèi)存塊的起始地址與要輸入的分配的內(nèi)存塊天小之和的值賦予N塊的起始地址
P[N].size=j[i].size-m; //該內(nèi)存塊的起始地址減去要輸入的分配的內(nèi)存塊大小所得的值賦N塊的內(nèi)存夫小
j[i].size=m; //把所輸入的分配的內(nèi)存塊大小的值賦給該塊的內(nèi)存大小
for(int p=0;p<N;p++)
{
if(P[p].startaddress==j[i].startaddress)
P[p].size=m;
}
l=1; //l設置為1
N++; //將N個地址塊變?yōu)镹+1個地址塊的塊號
}
l=1;
break;
}
}
if(l==1||i<N)
{
printf("Address allocate successful\n\n");
printf("state!!!!!!!!!!\n");
}
else printf("No used memory space!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
}快速適應分配算法
快速適應(quick fit)分配算法。該算法為那些經(jīng)常用到的長度的空閑區(qū)設立單獨的空閑區(qū)鏈表。例如，有一個n項的表，此表第一項是指向長度為2KB的空閑區(qū)鏈表表頭的指針，第二項是指向長度為4KB的空閑區(qū)鏈表表頭的指針，第三項是指向長度為8KB的空閑區(qū)鏈表表頭的指針，依此類推。像9KB這樣的空閑區(qū)既可放在8KB的鏈表中也可放在一個特殊的空閑區(qū)鏈表中。此算法查找十分快速，只要按進程長度直接搜索能容納它的最小空閑區(qū)鏈表并取第一塊分配，但歸還內(nèi)存空間時與相鄰空閑區(qū)的合并既復雜又費時。
優(yōu)點：該算法在分配時，不會對任何分區(qū)產(chǎn)生分割，所以能保留大的分區(qū)，也不會產(chǎn)生內(nèi)存碎片。
缺點：在分區(qū)歸還主存時算法復雜，系統(tǒng)開銷較大。在分配空閑分區(qū)時是以進程為單位，一個分區(qū)只屬于一個進程，存在一定的浪費。空間換時間。
以下是快速適應分配算法的初始化函數(shù)，本函數(shù)是1024kb內(nèi)存初始化，因為快速適應算法類似于二分法，剩余內(nèi)存取決于第一個作業(yè)的大小且都是2的冪（1，2，4，8，16.....）。文章來源：http://www.zghlxwxcb.cn/news/detail-775592.html
void init(struct Info info[] , int num)//本函數(shù)是1024kb內(nèi)存初始化，因為快速適應算法類似于二分法。
{
int i,j;
for(i=0; i<11; i++)
{
if(pow(2,9)<=num && num<pow(2,10))
{
info[i].size = 1024;
info[i] .startadress = 0;
info[i].state = 1;
info[i+1].size = 1024 - num;
info[i+1] .startadress = info[i].size;
info[i+1].state = 0;
i=1;
break;
}
if(pow(2,8)<=num && num<pow(2,9))//300
{
info[i].size = 512;
info[i] .startadress = 0;
info[i].state = 1;
info[i+1].size = 512;
info[i+1] .startadress = 512;
info[i+1].state = 0;
i=2;
break;
}
if(pow(2,7)<=num && num<pow(2,8))
{
info[i].size = 256;
info[i] .startadress = 0;
info[i].state = 1;
info[i+1].size = 256;
info[i+1] .startadress = 256;
info[i+1].state = 0;
info[i+2].size = 512;
info[i+2] .startadress =512;
info[i+2].state = 0;
i=3;
break;
}
if(pow(2,6)<=num && num<pow(2,7))
{
info[i].size = 128;
info[i] .startadress = 0;
info[i].state = 1;
info[i+1].size = 128;
info[i+1] .startadress = 128;
info[i+1].state = 0;
info[i+2].size = 256;
info[i+2] .startadress = 256;
info[i+2].state = 0;
info[i+3].size = 512;
info[i+3] .startadress = 512;
info[i+3].state = 0;
i=4;
break;
}
if(pow(2,5)<=num && num<pow(2,6))
{
info[i].size = 64;
info[i] .startadress = 0;
info[i].state = 1;
info[i+1].size = 64;
info[i+1] .startadress = 64;
info[i+1].state = 0;
info[i+2].size = 128;
info[i+2] .startadress = 128;
info[i+2].state = 0;
info[i+3].size = 256;
info[i+3] .startadress = 256;
info[i+3].state = 0;
info[i+4].size = 512;
info[i+4] .startadress = 512;
info[i+4].state = 0;
i=5;
break;
}
if(pow(2,4)<=num && num<pow(2,5))
{
info[i].size = 32;
info[i] .startadress = 0;
info[i].state = 1;
info[i+1].size = 32;
info[i+1] .startadress = 32;
info[i+1].state = 0;
info[i+2].size = 64;
info[i+2] .startadress = 64;
info[i+2].state = 0;
info[i+3].size = 128;
info[i+3] .startadress = 128;
info[i+3].state = 0;
info[i+4].size = 256;
info[i+4] .startadress = 256;
info[i+4].state = 0;
info[i+5].size = 512;
info[i+5] .startadress = 512;
info[i+5].state = 0;
i=6;
break;
}
if(pow(2,3)<=num && num<pow(2,4))
{
info[i].size = 16;
info[i] .startadress = 0;
info[i].state = 1;
info[i+1].size = 16;
info[i+1] .startadress = 16;
info[i+1].state = 0;
info[i+2].size = 32;
info[i+2] .startadress = 32;
info[i+2].state = 0;
info[i+3].size = 64;
info[i+3] .startadress = 64;
info[i+3].state = 0;
info[i+4].size = 128;
info[i+4] .startadress = 128;
info[i+4].state = 0;
info[i+5].size = 256;
info[i+5] .startadress = 256;
info[i+5].state = 0;
info[i+6].size = 512;
info[i+6] .startadress = 512;
info[i+6].state = 0;
i=7;
break;
}
if(pow(2,2)<=num && num<pow(2,3))
{
info[i].size = 8;
info[i] .startadress = 0;
info[i].state = 1;
info[i+1].size = 8;
info[i+1] .startadress = 8;
info[i+1].state = 0;
info[i+2].size = 16;
info[i+2] .startadress = 16;
info[i+2].state = 0;
info[i+3].size = 32;
info[i+3] .startadress = 32;
info[i+3].state = 0;
info[i+4].size = 64;
info[i+4] .startadress = 64;
info[i+4].state = 0;
info[i+5].size = 128;
info[i+5] .startadress = 128;
info[i+5].state = 0;
info[i+6].size = 256;
info[i+6] .startadress =256;
info[i+6].state = 0;
info[i+7].size = 512;
info[i+7] .startadress = 512;
info[i+7].state = 0;
i=8;
break;
}
if(2<num && num<=4)
{
info[i].size = 4;
info[i] .startadress = 0;
info[i].state = 1;
info[i+1].size = 4;
info[i+1] .startadress = 4;
info[i+1].state = 0;
info[i+2].size = 8;
info[i+2] .startadress = 8;
info[i+2].state = 0;
info[i+3].size = 16;
info[i+3] .startadress = 16;
info[i+3].state = 0;
info[i+4].size = 32;
info[i+4] .startadress = 32;
info[i+4].state = 0;
info[i+5].size = 64;
info[i+5] .startadress = 64;
info[i+5].state = 0;
info[i+6].size = 128;
info[i+6] .startadress = 128;
info[i+6].state = 0;
info[i+7].size = 256;
info[i+7] .startadress = 256;
info[i+7].state = 0;
info[i+8].size = 512;
info[i+8] .startadress = 512;
info[i+8].state = 0;
i=9;
break;
}
if(num==2)
{
info[i].size = 2;
info[i] .startadress = 0;
info[i].state = 1;
info[i+1].size = 2;
info[i+1] .startadress = 2;
info[i+1].state = 0;
info[i+2].size = 4;
info[i+2] .startadress = 4;
info[i+2].state = 0;
info[i+3].size = 8;
info[i+3] .startadress =8;
info[i+3].state = 0;
info[i+4].size = 16;
info[i+4] .startadress = 16;
info[i+4].state = 0;
info[i+5].size = 32;
info[i+5] .startadress = 32;
info[i+5].state = 0;
info[i+6].size = 64;
info[i+6] .startadress = 64;
info[i+6].state = 0;
info[i+7].size = 128;
info[i+7] .startadress = 128;
info[i+7].state = 0;
info[i+8].size = 256;
info[i+8] .startadress = 256;
info[i+8].state = 0;
info[i+9].size = 512;
info[i+9] .startadress = 512;
info[i+9].state = 0;
i=10;
break;
}
if(num==1)
{
info[i].size = 1;
info[i] .startadress = 0;
info[i].state = 1;
info[i+1].size = 1;
info[i+1] .startadress = 1;
info[i+1].state = 0;
info[i+2].size = 2;
info[i+2] .startadress = 2;
info[i+2].state = 0;
info[i+3].size = 4;
info[i+3] .startadress = 4;
info[i+3].state = 0;
info[i+4].size = 8;
info[i+4] .startadress =8;
info[i+4].state = 0;
info[i+5].size = 16;
info[i+5] .startadress = 16;
info[i+5].state = 0;
info[i+6].size = 32;
info[i+6] .startadress = 32;
info[i+6].state = 0;
info[i+7].size = 64;
info[i+7] .startadress = 64;
info[i+7].state = 0;
info[i+8].size = 128;
info[i+8] .startadress = 128;
info[i+8].state = 0;
info[i+9].size = 256;
info[i+9] .startadress = 256;
info[i+9].state = 0;
info[i+10].size = 512;
info[i+10] .startadress = 512;
info[i+10].state = 0;
i=11;
break;
}
}
struct Info q[10];int s=0,size;
for(int j=0;j<i;j++)
{
int x=0;
printf("%d",info[j].startadress);
for(size=info[j].size;size>0;size=size-100)
{
if( info[j].state == 1)
{
x+=1;
printf("\t1111111111\t已占用\n");
}
elseprintf("\t~~~~~~~~~~\n");
}
}
printf("Startaddress\tsize\tstate\n");
for(int j=0;j<i;j++)//用for循環(huán)，顯示內(nèi)存塊的分配狀況
{
printf("%3d\t %8d\t%4d\n",info[j].startadress,info[j].size,info[j].state);
}
}以下是快速適應分配算法函數(shù)：文章來源地址http://www.zghlxwxcb.cn/news/detail-775592.html
void buddy(struct Info info[], int num)
{
int i, j, k,n;
for(i=0; i<21; i++)
{
if( info[i].size >= num&&info[i].state == 0&&info[i].size/2 <num)
{
info[i].state=1;
break;
}
else if(num>info[i].size)
{
continue;
}
else if(info[i].size >= num&&info[i].state == 0&&info[i].size/2 >=num)
{
for(int y=0;info[i].size/2>=num;y++)
{
if(info[i].size/2>=num)
{
info[i].size/=2;
info[i].state=1;
for(int l=0;l<21;l++)
{
if(info[l].size==0)
{
info[l].startadress=info[i].startadress+info[i].size;
info[l].size=info[i].size;
break;
}
}
}
}
break;
}
}
}
主函數(shù)代碼塊：
int main()
{ //主函數(shù)main()
int k=0; //定義一個整型變量k，用于選擇方法與退出
printf("Please choose the method\n");
while(k!=6) //當k不等于3時
{
printf("\n~~~~~~~~~~~~~Memorymethods~~~~~~~~~~~~~~~~");
printf("\nl.First method\n2.Best method\n3.Worst method\n4.Next method\n5.Buddy method");//第一種方法是最先適應內(nèi)存分配法，第二種方法是最優(yōu)適應內(nèi)存分配法
printf("\n6.Exit\n");//3為退出程序
printf("Please choose the method!");//提示輸入數(shù)字選擇哪種方法或退出程序
scanf("%d",&k);//輸入k的值
switch(k)
{
case 1:
while(1)
{
printf("\n Initialization(~~~~~~~表示內(nèi)存):\n");//打印此字符串，用于提示內(nèi)存初始化
print();
First();
if(getchar()=='e')
{
return 0;
}
}
break;
case 2:
while(1)
{
printf("\n Initialization(~~~~~~~表示內(nèi)存):\n");//打印此字符串，用于提示內(nèi)存初始化
print();
Best();
if(getchar()=='e')
{
return 0;
}
}
break;
case 3:
while(1)
{
printf("\n Initialization(~~~~~~~表示內(nèi)存):\n");//打印此字符串，用于提示內(nèi)存初始化
print();
Worst();
if(getchar()=='e')
{
return 0;
}
}
break;
case 4:
while(1)
{
printf("\n Initialization(~~~~~~~表示內(nèi)存):\n");//打印此字符串，用于提示內(nèi)存初始化
print();
Next();
if(getchar()=='e')
{
return 0;
}
}
break;
continue;
case 5:
{
int num,x=0;
struct Info info[21]={{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0}};
printf("|1024|");
printf("\nPlease input the size:");
scanf("%d", &num);
x+=num;
init(info, num);
while(1)
{
printf("\nPlease input a num:");
scanf("%d", &num);
x+=num;
fflush(stdin);
if(x > 1023)
{
printf("The num is too big , try littler\n");
break;
}
else buddy(info,num);
bubbleprint(info);
}
system("pause");
}
case 6:
break;
default:printf("Choose error\n");
}
}
}運行結果：
到了這里，關于操作系統(tǒng)動態(tài)內(nèi)存分配算法【C語言實現(xiàn)】的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網(wǎng)！
