❶ 最差適配演算法【在線等+急+高分】
它從全部空閑區中找出能滿足作業要求的、且大小最大的空閑分區，從而使鏈表中的結點大小趨於均勻，適用於請求分配的內存大小范圍較窄的系統。為適應此演算法，空閑分區表（空閑區鏈）中的空閑分區要按大小從大到小進行排序，自表頭開始查找到第一個滿足要求的自由分區分配。
所以從頭查到尾，只要有合適的，他就會匹配。並且還要求節點大小趨於均勻這個特點
❷ 最差適配的平均查找長度
n個節點的二叉排序樹在最壞的情況下的平均查找長度為（n+1）/2。
二叉排序樹每個結點的C（i）為該結點的層次數。最壞情況下，當先後插入的關鍵字有序時，構成的二叉排序樹蛻變為單支樹，樹的深度為其平均查找長度（n+1）/2（和順序查找相同），最好的情況是二叉排序樹的形態和折半查找的判定樹相同，其平均查找長度和log 2 （n）成正比。
計算方法
最差適應演算法（Worst Fit）為適應此演算法，空閑分區表（空閑區鏈）中的空閑分區要按大小從大到小進行排序，自表頭開始查找到第一個滿足要求的自由分區分配。該演算法保留小的空閑區，盡量減少小的碎片產生。
最差適應演算法，也稱最差適配演算法，它從全部空閑區中找出能滿足作業要求的、且大小最大的空閑分區，從而使鏈表中的結點大小趨於均勻，適用於請求分配的內存大小范圍較窄的系統。
❸ c語言編寫程序，求兩個一維數組的最大值之差
#include<stdio.h>
#include<math.h>
main()
{
int i,j,m1,m2;
int a1,b1;
int a[100],b[100];
m1=m2=0;
printf("輸入第一個數組的長度：");
scanf("%d",&a1);
printf("輸入第一個數組：");
for(i=0;i<a1;i++)
{
scanf("%d",&a[i]);
if(m1<a[i])
m1=a[i];
}
printf("輸入第二個數組的長度：");
scanf("%d",&b1);
printf("輸入第一個數組：");
for(j=0;j<b1;j++)
{
scanf("%d",&b[j]);
if(m2<b[j])
m2=b[j];
}
printf("兩個數組最大值之差為：%d\n",abs(m1-m2));
}
❹ 求用C語言寫出首次適應分配演算法的分配過程~
/********************************
內存管理模擬程序
*******************************/
#include<iostream.h>
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include <time.h>
#include <windows.h>
/*定義宏*/
#define TotalMemSize 1024 /*劃分的物理塊的大小，地址范圍0~1023*/
#define MinSize 2 /*規定的不再分割的剩餘分區的大小*/
#define getpch(type) (type*)malloc(sizeof(type))
/*定義內存塊*/
typedef struct memBlock
{
struct memBlock *next;/*指向下一個塊*/
int stAddr; /*分區塊的初始地址*/
int memSize; /*分區塊的大小*/
int status; /*分區塊的狀態，0：空閑，1：以被分配*/
}MMB;
/*定義全局變數*/
MMB *idleHead=NULL; /*空閑分區鏈表的頭指針*/
MMB *usedHead=NULL; /*分配分區鏈表的頭指針*/
MMB *usedRear=NULL; /*分配分區鏈表的鏈尾指針*/
MMB *np; /*循環首次適應演算法中指向即將被查詢的空閑塊*/
int idleNum=1;/*當前空閑分區的數目*/
int usedNum=0;/*當前已分配分區的數目*/
MMB *memIdle=NULL; /*指向將要插入分配分區鏈表的空閑分區*/
MMB *memUsed=NULL; /*指向將要插入空閑分區鏈表的已分配分區*/
int flag=1;/*標志分配是否成功，1：成功*/
/*函數聲明*/
void textcolor (int color);/*輸出著色*/
void InitMem();/*初始化函數*/
int GetUseSize(float miu,float sigma); /*獲得請求尺寸*/
MMB *SelectUsedMem(int n);/*選擇待釋放的塊*/
void AddToUsed();/*將申請到的空閑分區加到分配分區鏈表中*/
int RequestMemff(int usize); /*請求分配指定大小的內存,首次適應演算法*/
int RequestMemnf(int usize); /*請求分配指定大小的內存,循環首次適應演算法*/
void AddToIdle();/*將被釋放的分配分區加到空閑分區鏈表中(按地址大小）*/
void ReleaseMem(); /*釋放指定的分配內存塊*/
/*主函數*/
void main()
{
int sim_step;
float miu,sigma; /*使隨機生成的請求尺寸符合正態分布的參數*/
int i;
int a;
MMB *p;
/* double TotalStep=0,TotalSize=0,TotalRatio=0,TotalUSize=0,Ratio=0,n=0;
double aveStep=0,aveSize=0,aveRatio=0;
int step=0,usesize=0; */
textcolor(11);
printf("\n\t\t內存管理模擬程序\n\n");
/* InitMem();*/
while(true)
{
double TotalStep=0,TotalSize=0,TotalRatio=0,TotalUSize=0,Ratio=0,n=0;
double aveStep=0,aveSize=0,aveRatio=0;
int step=0,usesize=0;
InitMem();
textcolor(12);
printf("\n\n首次適應演算法： 0");
printf("\n循環首次適應演算法： 1\n");
textcolor(11);
printf("\n請選擇一種演算法：");
scanf("%d",&a);
textcolor(15);
printf("\n輸入一定數量的步數：(sim_step)");
scanf("%d",&sim_step);
printf("\n 輸入使隨機生成的請求尺寸符合正態分布的參數：miu,sigma ");
scanf("%f,%f",&miu,&sigma);
for(i=1;i<=sim_step;i++)
{
textcolor(10);
printf("\n\n#[%d]\n",i);
do{
usesize=GetUseSize(miu,sigma);
while((usesize<0)||(usesize>TotalMemSize))
{
usesize=GetUseSize(miu,sigma);
}
textcolor(13);
printf("\n\n申請的內存尺寸為：%d",usesize);
printf("\n此時可用的空閑分區有 %d 塊情況如下：",idleNum);
p=idleHead;
textcolor(15);
while(p!=NULL)
{
printf("\n始址:%d\t 尺寸：%d",p->stAddr,p->memSize);
p=p->next;
}
TotalSize+=usesize;
if(a==0)
step=RequestMemff(usesize);
else
step=RequestMemnf(usesize);
TotalStep+=step;
n++;
}while(flag==1);
p=usedHead;
while(p!=NULL)
{
TotalUSize+=p->memSize;
printf("\n始址:%d\t 尺寸：%d",p->stAddr,p->memSize);
p=p->next;
}
textcolor(11);
if(TotalUSize!=0)
{
Ratio=TotalUSize/TotalMemSize;
TotalUSize=0;
printf("\n內存利用率NO.%d :%f%c",i,100*Ratio,'%');
}
else
{
Ratio=0;
printf("\n內存利用率NO.%d :%c%c",i,'0','%');
}
TotalRatio+=Ratio;
ReleaseMem();
}
if(n!=0)
{
textcolor(10);
aveStep=TotalStep/n;
aveSize=TotalSize/n;
aveRatio=TotalRatio/sim_step;
printf("\n平均搜索步驟：%f",aveStep);
printf("\n平均請求尺寸：%f",aveSize);
printf("\n平均內存利用率：%f",aveRatio);
}
}
}
// 輸出著色 /////////////////////////////////////////
void textcolor (int color)
{
SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color );
}
/******************************
函數名：InitMem()
用途：把內存初始化為一整塊空閑塊
****************************************/
void InitMem()
{
MMB *p;
p=getpch(MMB);
p->memSize=TotalMemSize;
p->stAddr=0;
p->status=0;
p->next=NULL;
idleHead=p;
np=idleHead;
usedHead=NULL;
usedRear=NULL;
idleNum=1;
usedNum=0;
flag=1;
memIdle=NULL;
memUsed=NULL;
}
/******************************
函數名：GetUseSize(float miu,float sigma)
用途：獲得請求尺寸；
參數說明：float miu,float sigma ：正態分布的參數
返回值:申請尺寸的大小；
****************************************************/
int GetUseSize(float miu,float sigma)
{
float r1,r2;
float u,v,w;
float x,y;
do
{
r1=rand()/32767.0;
r2=rand()/32767.0;
u=2*r1-1;
v=2*r2-1;
w=u*u+v*v;
}while(w>1);
x=u*sqrt(((-log(w))/w));
y=v*sqrt(((-log(w))/w));
return miu+sigma*x;
}
/******************************
函數名：*SelectUsedMem(int n)
用途：選擇待釋放的塊(0~n-1)
返回值：指向待釋放的塊的指針；
****************************************************/
MMB *SelectUsedMem(int n)
{
MMB *p;
int i,j;
if(n>0)
{
i = rand()%n ;
textcolor(5);
printf("\n\n當前已分配分區總數為：%d",n);
printf("\n待釋放塊的序號為：%d\n",i );
p=usedHead;
if(p!=NULL)
{
for(j=i;j>0;j--)
p=p->next;
return(p);
}
else
return(NULL);
}
else
{
printf("\n當前沒有可釋放的資源！\n");
}
}
/******************************
函數名：AddToUsed()
用途：將申請到的空閑分區加到分配分區鏈表中
***************************************************************/
void AddToUsed()
{
MMB *p;
memIdle->status=1;
if(usedHead==NULL)
{
usedHead=memIdle;
usedRear=usedHead;
}
else
{
usedRear->next=memIdle;
usedRear=memIdle;
}
usedNum++;
printf("\n當前分配分區共有%d塊！",usedNum);
p=usedHead;
while(p!=NULL)
{
printf("\n始址:%d \t 尺寸：%d",p->stAddr,p->memSize);
p=p->next;
}
}
/******************************
函數名：RequestMemff(int usize)
參數說明：usize：請求尺寸的大小；
用途：請求分配指定大小的內存,首次適應演算法
返回值：搜索步驟
***************************************************************/
int RequestMemff(int usize)
{
MMB *p1,*p2,*s;
int step;
int suc=0;
int size1,size2;
if(idleHead==NULL)
{
flag=0;
textcolor(12);
printf("\n分配失敗！");
return 0;
}
else
{
if((idleHead->memSize)>usize)
{
size1=(idleHead->memSize)-usize;
if(size1<=MinSize)
{
memIdle=idleHead;
idleHead=idleHead->next;
memIdle->next=NULL;
idleNum--;
}
else
{
s=getpch(MMB);
s->memSize=usize;
s->stAddr=idleHead->stAddr;
s->status=1;
s->next=NULL;
memIdle=s;
idleHead->memSize=idleHead->memSize-usize;
idleHead->stAddr=idleHead->stAddr+usize;
}
step=1;
flag=1;
textcolor(12);
printf("\n分配成功！");
AddToUsed();
}
else
{
p1=idleHead;
step=1;
p2=p1->next;
while(p2!=NULL)
{
if((p2->memSize)>usize)
{
size2=(p2->memSize)-usize;
if(size2<=MinSize)
{
p1->next=p2->next;
memIdle=p2;
memIdle->next=NULL;
idleNum--;
}
else
{
s=getpch(MMB);
s->memSize=usize;
s->stAddr=p2->stAddr;
s->status=1;
s->next=NULL;
memIdle=s;
p2->memSize=p2->memSize-usize;
p2->stAddr=p2->stAddr+usize;
}
flag=1;
suc=1;
textcolor(12);
printf("\n分配成功！");
AddToUsed();
p2=NULL;
}
else
{
p1=p1->next;
p2=p2->next;
step++;
}
}
if(suc==0)
{
flag=0;
textcolor(12);
printf("\n分配失敗！");
}
}
}
return step;
}
/******************************
函數名：AddToIdle()
用途：將被釋放的分配分區加到空閑分區鏈表中(按地址遞增順序排列）
***************************************************************/
void AddToIdle()
{
MMB *p1,*p2;
int insert=0;
if((idleHead==NULL))
{
idleHead=memUsed;
idleNum++;
np=idleHead;
}
else
{
int Add=(memUsed->stAddr)+(memUsed->memSize);
if((memUsed->stAddr<idleHead->stAddr)&&(Add!=idleHead->stAddr))
{
memUsed->next=idleHead;
idleHead=memUsed;
idleNum++;
}
else
{
if((memUsed->stAddr<idleHead->stAddr)&&(Add==idleHead->stAddr))
{
idleHead->stAddr=memUsed->stAddr;
idleHead->memSize+=memUsed->memSize;
}
else
{
p1=idleHead;
p2=p1->next;
while(p2!=NULL)
{
if(memUsed->stAddr>p2->stAddr)
{
p1=p1->next;
p2=p2->next;
}
else
{
int Add1=p1->stAddr+p1->memSize;
int Add2=p2->stAddr-memUsed->memSize;
if((Add1==memUsed->stAddr)&&(memUsed->stAddr!=Add2))
{
p1->memSize=p1->memSize+memUsed->memSize;
}
if((Add1!=memUsed->stAddr)&&(memUsed->stAddr==Add2))
{
p2->memSize=p2->memSize+memUsed->memSize;
p2->stAddr=memUsed->stAddr;
}
if((Add1!=memUsed->stAddr)&&(memUsed->stAddr!=Add2))
{
memUsed->next=p2;
p1->next=memUsed;
if(np->stAddr==p2->stAddr)
np=p1->next;
idleNum++;
}
if((Add1==memUsed->stAddr)&&(memUsed->stAddr==Add2))
{
p1->memSize=p1->memSize+memUsed->memSize+p2->memSize;
p1->next=p2->next;
if((np->stAddr)==(p2->stAddr))
np=p1;
idleNum--;
}
p2=NULL;
insert=1;
}
}
if(insert==0)
{
p1->next=memUsed;
idleNum++;
}
}
}
}
}
/******************************
函數名：ReleaseMem()
用途：釋放指定的分配內存塊
***************************************************************/
void ReleaseMem()
{
MMB *q1,*q2;
MMB *s;
if(usedNum==0)
{
printf("\n當前沒有分配分區!");
return;
}
else
{
s=SelectUsedMem(usedNum);
if(s!=NULL)
{
if(s->stAddr==usedHead->stAddr)
{
memUsed=usedHead;
usedHead=usedHead->next;
memUsed->next=NULL;
AddToIdle();
usedNum--;
}
else
{
q1=usedHead;
q2=q1->next;
while(q2!=NULL)
{
if(q2->stAddr!=s->stAddr)
{
q1=q1->next;
q2=q2->next;
}
else
{
q1->next=q2->next;
memUsed=q2;
memUsed->next=NULL;
if(q1->next==NULL)
usedRear=q1;
AddToIdle();
usedNum--;
q2=NULL;
}
}
}
}
}
}
/******************************
函數名：RequestMemnf(int usize)
參數說明：usize：請求尺寸的大小；
用途：請求分配指定大小的內存,循環首次適應演算法
返回值：搜索步驟
***************************************************************/
int RequestMemnf(int usize)
{
MMB *p2,*p,*s;
int step;
int iNum=0;
int suc=0;
int size1,size2,size3;
if(idleHead==NULL)
{
flag=0;
printf("\n分配失敗！");
return 0;
}
else
{
iNum=idleNum;
while(iNum>0)
{
iNum--;
if((np->memSize)>usize)
{
/*指針指向的空閑塊滿足條件,且正好為頭指針*/
if(np->stAddr==idleHead->stAddr)
{
size1=(idleHead->memSize)-usize;
if(size1<=MinSize)
{
memIdle=idleHead;
idleHead=idleHead->next;
memIdle->next=NULL;
idleNum--;
}
else
{
s=getpch(MMB);
s->memSize=usize;
s->stAddr=idleHead->stAddr;
s->status=1;
s->next=NULL;
memIdle=s;
idleHead->memSize=idleHead->memSize-usize;
idleHead->stAddr=idleHead->stAddr+usize;
}
if((idleHead==NULL)||(idleHead->next==NULL))
np=idleHead;
else
np=idleHead->next;
}
else/*指針指向的空閑塊滿足條件,不為頭指針*/
{
size2=(np->memSize)-usize;
if(size2<=MinSize) /*從空閑鏈表中刪除*/
{
p=idleHead;
while(p->next->stAddr!=np->stAddr)
p=p->next;
p->next=np->next;
memIdle=np;
memIdle->next=NULL;
np=p;
idleNum--;
}
else
{
s=getpch(MMB);
s->memSize=usize;
s->stAddr=np->stAddr;
s->status=1;
s->next=NULL;
memIdle=s;
np->memSize=np->memSize-usize;
np->stAddr=np->stAddr+usize;
}
if(np->next==NULL)
np=idleHead;
else
np=np->next;
}
step=1;
flag=1;
suc=1;
textcolor(12);
printf("\n分配成功！");
AddToUsed();
iNum=0;
}
else /*當前指針指向的空閑區不滿足條件*/
{
step=1;
p2=np->next;
if(p2==NULL)
{
np=idleHead;
iNum--;
}
else
{
if((p2->memSize)>usize)
{
size3=(p2->memSize)-usize;
if(size3<=MinSize)
{
np->next=p2->next;
memIdle=p2;
memIdle->next=NULL;
idleNum--;
}
else
{
s=getpch(MMB);
s->memSize=usize;
s->stAddr=p2->stAddr;
s->status=1;
s->next=NULL;
memIdle=s;
p2->memSize=p2->memSize-usize;
p2->stAddr=p2->stAddr+usize;
}
flag=1;
suc=1;
printf("\n分配成功！");
AddToUsed();
if(p2->next==NULL)
np=idleHead;
else
np=p2->next;
p2=NULL;
iNum=0;
}
else
{
np=np->next;
p2=p2->next;
iNum--;
step++;
}
}
}
// iNum--;
}
if(suc==0)
{
flag=0;
textcolor(12);
printf("\n分配失敗！");
}
}
return step;
}
❺ 怎麼用C語言實現向前向後差分演算法
沒有初始化low，就會報運行時錯誤，初始化一下low就好了
#include
"stdio.h"
#define
List_Size
20
struct
RecordType
{
int
key;
//簡單查找
char
otherkey;
};
struct
RecordList
{
RecordType
r[List_Size+1];
int
length;
}list1,*p;
void
init_list()
{
int
i;
//初始化數據
p=&list1;
for(i=0;i<List_Size+1;i++)
{
p->r[i].key
=i;
p->r[i].otherkey
=i+1;
}
p->length
=List_Size+1;
for(i=0;i<List_Size+1;i++)
//確認初始化數據
{
printf("list.r[%d].key=%d,list.r[%d].otherkey=%d\n",i,p->r[i].key,i,p->r[i].otherkey);
}
printf("list.length=%d\n",p->length);
}
int
BinSrch(RecordList
L,int
k)
//二分差演算法
{
int
low,high,mid;
int
i=0;
low
=
0;
//初始化low
high=L.length-1;
while(low<=high)
{
mid=(low+high)/2;
if(k==L.r[mid].key)
{
i=mid;break;
}
else
{
if(k
<
L.r[mid].key)
{
high=mid-1;
}
else
low=mid+1;
}
}
//
if((low==high)&&(k!=L.r[mid].key))
//
{
//
return
(0);
//
}
return
(i);
}
void
main()
{
int
result=0;
p=&list1;
init_list();
result=BinSrch(list1,7);
printf("the
reslut=%d",result);
getchar();
}
❻ c語言一關於極差演算法問題
你的敘述不夠詳細，
極差
是指數列中的最大和最小值的差，而你又說必須要求此極差中較大數在
數列
中排的更靠前。那麼如果最大在最小的後面，你是應該移動他們的
順序
還是尋找之前的較大值還是之後的較小值?你不敘述清楚，這個
代碼
沒法編寫
❼ 最壞適應演算法 c語言
/**------------------------------------------------------
進入程序後可以根據菜單選項進入不同的模塊
1.使用首次適應演算法分配空間
2.使用最佳適應演算法分配空間
3.釋放一塊空間
4.顯示內存分配情況
5.退出系統
----------------------------------------------------------**/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#define MEMSIZE 100 /*定義內存大小為100*/
#define MINSIZE 2 /*如果小於此值 將不再分割內存*/
typedef struct _MemoryInfomation{/* 內存空間分區表 結構*/
int start; /*起始地址*/
int size; /*大小*/
char info; /*狀態 F:空閑(Free) U:佔用(Used) E 結束(end)*/
}MEMINFO;
MEMINFO MemList[MEMSIZE]; //內存空間信息表
void Display();
/*--------------------------------------------------------
函數名:InitALL()
功 能:初始化所有變數
--------------------------------------------------------*/
void InitAll(){
int i;
MEMINFO temp={0,0,'e'};
for(i=0;i<MEMSIZE;i++) //初始化空間信息表
MemList[i]=temp;
MemList[0].start=0; //起始地址為0
MemList[0].size=MEMSIZE;//空間初始為最大的
MemList[0].info='f'; //狀態為空閑
}
/*--------------------------------------------------------
函數名:FirstFit_new()
功 能:首次適應演算法分配內存
--------------------------------------------------------*/
void FirstFit_new(){
int i,j,size;
char temp[10];
printf("FirstFit_new:How many MEMORY requir?");
gets(temp);
size=atoi(temp); //將字元串轉化為整數
for(i=0; i < MEMSIZE-1 && MemList[i].info != 'e';i++) //到了空間尾且沒有空間分配
{
if(MemList[i].size >= size && MemList[i].info=='f') //滿足所需要的大小，且是空閑空間
{
if(MemList[i].size - size <= MINSIZE) //如果小於規定的最小差則將整個空間分配出去
MemList[i].info='u'; //標志為使用
else
{
for(j = MEMSIZE-2; j > i; j--) //將i後的信息表元素後移
{
MemList[j+1]=MemList[j];
}
//將i分成兩部分，使用低地址部分
MemList[i+1].start= MemList[i].start+size;
MemList[i+1].size = MemList[i].size-size;
MemList[i+1].info='f';
MemList[i].size=size;
MemList[i].info='u';
}
break;
}
}
if(i == MEMSIZE-1 || MemList[i].info=='e') //沒有找到符合分配的空間
{
printf("Not Enough Memory!!\n");
getchar();
}
Display();
}
/*--------------------------------------------------------
函數名:BestFit_new()
功 能:最佳適應演算法分配內存
--------------------------------------------------------*/
void BestFit_new()
{
int i,j,k,flag,size;
char temp[10];
printf("BestFit_new How many MEMORY requir?");
gets(temp);
size=atoi(temp); //將字元串轉化為整數
j=0;
flag=0; //標志是否有合適的空間分配，0無，1有
k=MEMSIZE; //用來保存滿足要求的最小空間
for(i=0;i<MEMSIZE-1 && MemList[i].info!='e';i++)
{
if(MemList[i].size >= size && MemList[i].info == 'f') //符合要求
{
flag=1;
if(MemList[i].size < k) //比符合要求的最小空間小，則交換
{
k=MemList[i].size;
j=i;
}
}
}
i=j;
if(flag == 0) //沒找到
{
printf("Not Enough Memory!\n");
getch();
j=i;
}
else if(MemList[i].size - size <= MINSIZE) //小於規定的最小差，將整個空間分配
MemList[i].info='u';
else
{
for(j = MEMSIZE-2; j > i; j--) //後移
MemList[j+1]=MemList[j];
MemList[i+1].start=MemList[i].start+size;
MemList[i+1].size=MemList[i].size-size;
MemList[i+1].info='f';
MemList[i].size=size;
MemList[i].info='u';
}
Display();
}
/*--------------------------------------------------------
最壞適應演算法
*/
void BadFit_new()
{
int i,j,k,flag,size;
char temp[10];
printf("BadFit_new How many MEMORY requir?");
gets(temp);
size=atoi(temp);
j=0;
flag=0;
k=0; //保存滿足要求的最大空間
for(i=0;i<MEMSIZE-1&&MemList[i].info!='e';i++)
{
if(MemList[i].size>=size&&MemList[i].info=='f')
{
flag=1;
if(MemList[i].size>k)
{
k=MemList[i].size;
j=i;
}
}
}
i=j;
if(flag=0)
{
printf("Not Enough Memory!\n");
getch();
j=i;
}
else if(MemList[i].size-size<=MINSIZE)
MemList[i].info='u';
else
{
for(j=MEMSIZE-2;j>i;j--)
MemList[j+1]=MemList[j];
MemList[i+1].start=MemList[i].start+size;
MemList[i+1].size=MemList[i].size-size;
MemList[i+1].info='f';
MemList[i].size=size;
MemList[i].info='u';
}
Display();
}
/*--------------------------------------------------------
函數名:del()
功 能:釋放一塊內存
--------------------------------------------------------*/
void del()
{
int i,number;
char temp[10];
printf("\nplease input the NUMBER you want stop:");
gets(temp);
number=atoi(temp);
if(MemList[number].info == 'u') //輸入的空間是使用的
{
MemList[number].info = 'f'; //標志為空閑
if(MemList[number+1].info == 'f') //右空間為空則合並
{
MemList[number].size+=MemList[number+1].size; //大小合並
for(i=number+1;i < MEMSIZE-1 && MemList[i].info !='e';i++)/* i後的空間信息表元素前移 */
if(i>0)
MemList[i]=MemList[i+1];
}
if(number > 0 && MemList[number-1].info=='f') //左空間空閑則合並
{
MemList[number-1].size+=MemList[number].size;
for(i=number;i<MEMSIZE-1&&MemList[i].info!='e';i++)
MemList[i]=MemList[i+1];
}
}
else
{
printf("Thist Number is Not exist or is Not used!\n ");
getchar();
}
Display();
}
/*--------------------------------------------------------
函數名:Display()
功 能:顯示內存狀態
--------------------------------------------------------*/
void Display(){
int i,
used=0; //記錄可以使用的總空間量
/* clrscr();*/
printf("\n----------------------------------------------\n");
printf("%5s%15s%15s","Number","start","size","Info");
printf("\n----------------------------------------------\n");
for(i=0;i < MEMSIZE && MemList[i].info != 'e';i++)
{
if(MemList[i].info == 'u')
used+=MemList[i].size;
printf("%5d%15d%15d%15s\n",i,MemList[i].start,MemList[i].size,MemList[i].info=='u'?"USED":"FREE");
}
printf("\n----------------------------------------------\n");
printf("Totalsize:%-10d Used:%-10d Free:%-10d\n",MEMSIZE,used,MEMSIZE-used);
printf("\n\n Press Any Key to return...");
getch();
}
/*--------------------------------------------------------
函數名:main()
功 能:主函數
--------------------------------------------------------*/
void main(){
char ch;
InitAll();
while(1){
printf("========================================================\n");
printf(" 1.Get a block use the FISTFIT method\n");
printf(" 2.Get a block use the BESTFIT method\n");
printf(" 3.Get a block use the BadFIT method\n");
printf(" 4.Free a block\n");
printf(" 5.Display Mem info \n");
printf(" 6.Exit \n");
printf("========================================================\n");
ch=getch();
switch(ch){
case '1':FirstFit_new();break; //首次適應演算法
case '2':BestFit_new();break; //最佳適應演算法
case '3':BadFit_new();break; //最壞適應演算法
case '4':del();break; //刪除已經使用完畢的空間
case '5':Display();break; //顯示內存分配情況
case '6':exit(0);
}
}
}