純c語言寫動態分割槽分配演算法的FirstFit和BestFit

阿新 • • 發佈：2019-01-02

主要參考連結：

動態分割槽分配：

https://blog.csdn.net/houchaoqun_xmu/article/details/55541299

https://blog.csdn.net/cm_cyj_1116/article/details/53518790

1.程序排程演算法FCFS和RR

2.作業排程演算法SJF，HRRN

3.動態分割槽分配演算法的FirstFit和BestFit

個人感想：動態分割槽分配和另外兩個有點不一樣，一開始看到的時候對它的資料結構有點懵。

主要的資料結構（記憶體空閒分割槽的地址直接用陣列順序儲存了，地址大小順序按照陣列下標

#define MAXNUMBER 100
static int MinPartitionNum;//事先規定的不再切割的剩餘分割槽的大小 
static int PartitionNum;  //記憶體中空閒分割槽的個數
static int ProcessNum; //需要分配的程序個數
static int FreePartition[MAXNUMBER];  //空閒分割槽對應的記憶體
static int ProcessNeed[MAXNUMBER];  //需要分配的程序大小
 
static int LeftFreePartition[MAXNUMBER];
//static int LeftProcessNeed[MAXNUMBER];//參考連結有這個，但我不知道什麼來的就沒要它了 
 
static char ProcessName[MAXNUMBER];
static char NameProcessToPartition[MAXNUMBER][MAXNUMBER];
 
struct free_node//這個用在BestFit演算法裡
{
	int partitionSize;
	int id;
};

用到的函式

void readDataFunction();//向文字讀入資料
void initial();//初始化
void FirstFit();
void BestFit();
void sort(free_node *p,int PartitionNum);//BestFit所需要的排序
void display();//顯示最終結果 
void display_sort(free_node *p,int PartitionNum);//具體顯示BestFit的排序 
void display_insert(); //顯示輸入的資料

核心演算法

void FirstFit()
{
	printf("***********首次適應演算法***********\n"); 
	initial();
    display_insert();
	 
	int i,j;
	for (i = 0;i<ProcessNum;i++)   //逐個遍歷每個程序
	{
		for (j = 0;j<PartitionNum;j++)   //每次都從分割槽的首地址開始查詢
		{
			if (ProcessNeed[i] <= (LeftFreePartition[j]-MinPartitionNum) && LeftFreePartition!=0)  //程序需要的資源要<=空閒分割槽大小-事先規定的不再切割的剩餘分割槽的大小

			{
				LeftFreePartition[j] -= ProcessNeed[i];   //扣除分配給程序的資源
				NameProcessToPartition[i][j] = ProcessName[i];  //儲存各個程序所在的分割槽位置
				break;   //!!!很重要，一個程序分割槽完後，應該立即break，進行下一個程序的判斷
			}
		}
	}
 
	display();
	
}

//思想：利用氣泡排序對分割槽大小進行排序，但不改變原分割槽的位置
void sort(free_node *p,int PartitionNum)//對記憶體容量進行從小到大的排序（BestFit要用到的
{ 
	for(int i=0;i<PartitionNum;i++)
		for(int j=i+1;j<PartitionNum;j++)
	      if(p[i].partitionSize>p[j].partitionSize)
         {
	      	free_node temp;
	      	temp=p[i];
	      	p[i]=p[j];
	      	p[j]=temp;
         }
}

void BestFit()
{
	//建立一個結構體，包括分割槽大小和所對應的id，排序過程中，每改變順序一次，id隨著改變
	//關鍵：每次分配完一個程序的記憶體大小後，都要重新排序
	printf("***********最佳適應演算法***********\n"); 
	initial();
	display_insert();
	
	int i,j;

	free_node best[MAXNUMBER];

	for (i = 0;i<PartitionNum;i++)
	{
		//初始化結構體
		best[i].partitionSize = FreePartition[i];
		best[i].id = i;
	}
    
	for (i = 0;i<ProcessNum;i++)
	{
        sort(best,PartitionNum);
        printf("\n第%d次排序：       ",i+1);
        display_sort(best,PartitionNum);
		  
	for (j = 0;j<PartitionNum;j++)
		{
//			if (ProcessNeed[i] <= best[j].partitionSize)//沒有“剩餘分割槽最小不少於”的限制 
			if(ProcessNeed[i] <= (best[j].partitionSize-MinPartitionNum) && best[j].partitionSize!=0)
			{
				best[j].partitionSize -= ProcessNeed[i];
				NameProcessToPartition[i][best[j].id] = ProcessName[i];
				break;
			}
		}
		
		LeftFreePartition[best[j].id] = best[j].partitionSize;
	}
	display();
}

測試資料的輸入

原始碼

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

#define MAXNUMBER 100
static int MinPartitionNum;//事先規定的不再切割的剩餘分割槽的大小 
static int PartitionNum;  //記憶體中空閒分割槽的個數
static int ProcessNum; //需要分配的程序個數
static int FreePartition[MAXNUMBER];  //空閒分割槽對應的記憶體
static int ProcessNeed[MAXNUMBER];  //需要分配的程序大小
 
static int LeftFreePartition[MAXNUMBER];
//static int LeftProcessNeed[MAXNUMBER];//沒要它了 
 
static char ProcessName[MAXNUMBER];
static char NameProcessToPartition[MAXNUMBER][MAXNUMBER];
 
struct free_node
{
	int partitionSize;
	int id;
};

void readDataFunction();//向文字讀入資料
void initial();//初始化
void FirstFit();
void BestFit();
void sort(free_node *p,int PartitionNum);//BestFit所需要的排序
void display();//顯示最終結果 
void display_sort(free_node *p,int PartitionNum);//具體顯示BestFit的排序 
void display_insert(); //顯示輸入的資料 

void readDataFunction(){
	FILE *fp;
	fp=fopen("data.txt","r");
    if(fp==NULL){
		exit(EXIT_FAILURE);
	}
	fscanf(fp,"%d",&MinPartitionNum);
	fscanf(fp,"%d",&PartitionNum);
	for (int i=0;i<PartitionNum;i++)
	{
		fscanf(fp,"%d",&FreePartition[i]);
	}
	fscanf(fp,"%d",&ProcessNum);
	for (int i=0;i<ProcessNum;i++)
	{
		fscanf(fp," %c ",&ProcessName[i]);
	}
	for (int i=0;i<ProcessNum;i++)
	{
		fscanf(fp,"%d",&ProcessNeed[i]);
	}
	
}

void initial()
{
	readDataFunction();   //讀取原始資料
	for (int i=0;i<ProcessNum;i++)
	{	
		for (int j =0;j<PartitionNum;j++)
		{
			NameProcessToPartition[i][j] =NULL;
			LeftFreePartition[j] = FreePartition[j];
		}
	}
}

void display_insert(){
	printf("剩餘分割槽最小不少於：%d\n",MinPartitionNum);
	printf("需要分配記憶體的程序名：");
	for (int i = 0;i<ProcessNum;i++)
	{
		printf("       %c   ",ProcessName[i]);//僅僅為了輸出好看而已 
	}

	printf("\n需要分配記憶體的程序分割槽大小：");
	for (int i = 0;i<ProcessNum;i++)
	{
		printf("%2d         ",ProcessNeed[i]);
	}
	printf("\n\n");
		
	printf("輸入時的分割槽序號：");
	for (int i = 0;i<PartitionNum;i++)
	{
		printf("分割槽%d      ",i+1);
	}
	printf("\n分割槽大小：");
	for (int i = 0;i<PartitionNum;i++)
	{  
	    printf("         %2d",FreePartition[i]);
	}
	
}

void FirstFit()
{
	printf("***********首次適應演算法***********\n"); 
	initial();
    display_insert();
	 
	int i,j;
	for (i = 0;i<ProcessNum;i++)   //逐個遍歷每個程序
	{
		for (j = 0;j<PartitionNum;j++)   //每次都從分割槽的首地址開始查詢
		{
			if (ProcessNeed[i] <= (LeftFreePartition[j]-MinPartitionNum) && LeftFreePartition!=0)  //當系統記憶體分割槽足夠大的時候，即分配給程序資源
//			if (ProcessNeed[i] <= LeftFreePartition[j] && LeftFreePartition!=0)  //當系統記憶體分割槽足夠大的時候，即分配給程序資源
			{
				LeftFreePartition[j] -= ProcessNeed[i];   //扣除分配給程序的資源
 
				NameProcessToPartition[i][j] = ProcessName[i];  //儲存各個程序所在的分割槽位置
 
				break;   //!!!很重要，一個程序分割槽完後，應該立即break，進行下一個程序的判斷
			}
		}
	}
 
	display();
	
}

void sort(free_node *p,int PartitionNum)//對記憶體容量進行從小到大的排序
{ 
	for(int i=0;i<PartitionNum;i++)
		for(int j=i+1;j<PartitionNum;j++)
	      if(p[i].partitionSize>p[j].partitionSize)
		  {
	      	free_node temp;
	      	temp=p[i];
	      	p[i]=p[j];
	      	p[j]=temp;
		  }
}

void display_sort(free_node *p,int PartitionNum)
{
	for (int i = 0;i<PartitionNum;i++)
      {
		 printf("分割槽%d      ",p[i].id+1);
	  }
	    printf("\n分割槽大小：");
	    
	    for (int i = 0;i<PartitionNum;i++)
	  {  
	     printf("         %2d",p[i].partitionSize);
	  }
}

void BestFit()
{
	//思想：利用氣泡排序對分割槽大小進行排序，但不改變原分割槽的位置
	//建立一個結構體，包括分割槽大小和所對應的id，排序過程中，每改變順序一次，id隨著改變
	//關鍵：每次分配完一個程序的記憶體大小後，都要重新排序
	printf("***********最佳適應演算法***********\n"); 
	initial();
	display_insert();
	
	int i,j;
 
	free_node best[MAXNUMBER];
	
	for (i = 0;i<PartitionNum;i++)
	{
		//初始化結構體
		best[i].partitionSize = FreePartition[i];
		best[i].id = i;
	}
    
	for (i = 0;i<ProcessNum;i++)
	{
        sort(best,PartitionNum);
        printf("\n第%d次排序：       ",i+1);
        display_sort(best,PartitionNum);
		  		  
		for (j = 0;j<PartitionNum;j++)
		{
			if(ProcessNeed[i] <= (best[j].partitionSize-MinPartitionNum) && best[j].partitionSize!=0)
			{
				best[j].partitionSize -= ProcessNeed[i];
				NameProcessToPartition[i][best[j].id] = ProcessName[i];
				break;
			}
		}
		
		LeftFreePartition[best[j].id] = best[j].partitionSize;
	}
    printf("\n");
	display();
}

void display()
{
	int i;
    printf("\n分割槽序號：");

	for (i = 0;i<PartitionNum;i++)
	{
		printf("分割槽%d ",i+1);
	}
	printf("\n分割槽大小：");
	for (i = 0;i<PartitionNum;i++)
	{  
	    printf(" %4d ",FreePartition[i]);
	}
	printf("\n剩餘大小：");
	for (i = 0;i<PartitionNum;i++)
	{
		printf(" %4d ",LeftFreePartition[i]);
	}
	printf("\n分配程序情況：\n");
	for (i = 0;i<PartitionNum;i++)
	{
		for (int j = 0;j<ProcessNum;j++)
		{
			if (NameProcessToPartition[j][i]!=NULL)
			{
				printf("%c:--->分割槽%d\n",NameProcessToPartition[j][i],i+1); 
			}		
		}	
	}
	printf("\n***************結束***************\n");
}


int main(void){	
	int a;
	printf("動態分割槽分配演算法：1.FirstFit 2.BestFit 3.quit\n");
	scanf("%d",&a);
	while(a!=3){
	
	switch(a){
		case 1:
		FirstFit();
		break; 
		
		case 2:
		BestFit();
		break; 
		 
		case 3: 
		printf("end.\n");
		
		default:
		 break; 
	}
//    system("cls");
	printf("\n動態分割槽分配演算法：1.FirstFit 2.BestFit 3.quit\n");
	scanf("%d",&a);
}
	
	return 0;
}

實驗截圖

FirstFit的結果

BestFit的結果

純c語言寫動態分割槽分配演算法的FirstFit和BestFit

主要參考連結：動態分割槽分配： https://blog.csdn.net/houchaoqun_xmu/article/details/55541299 https://blog.csdn.net/cm_cyj_1116/article/details/53518790 &nbs

【作業系統】C語言模擬作業系統實現動態分割槽分配演算法

#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<string.h> #include<stdlib.h> #include<math.h> #defi

動態分割槽分配演算法

基於順序搜尋的動態分割槽分配演算法 1.首次適應演算法(FF)：所謂的首次的意思以地址遞增連結。因此在分配記憶體的時候，從鏈首開始查詢，直到找到一個大小能滿足要求的空閒分割槽為之。 2.迴圈首次適應演算法(NF)：和首次適應演算法的區別就是，在為程序分配記憶體空間的時候，不再是都

【C語言】動態記憶體分配小結

為什麼存在動態記憶體分配？我們已經掌握的記憶體開闢方式有： int val = 20;//在棧空間上開闢四個位元組 char arr[10];//在棧空間上開闢10個位元組的連續空間但是上面開闢空間的方式有兩個特點： 1.空間開闢的大小是固定的 2.陣列在申明的時

純C語言寫的按鍵驅動，將按鍵邏輯與按鍵處理事件分離~

button drive 傑傑自己寫的一個按鍵驅動，支援單雙擊、連按、長按；採用回撥處理按鍵事件（自定義消抖時間），使用只需3步，建立按鍵，按鍵事件與回撥處理函式連結對映，週期檢查按鍵。原始碼地址：https://github.com/jiejieTop/Bu

4】動態分割槽分配演算法

// 作業系統_實驗四（動態分割槽分配演算法）.cpp : 定義控制檯應用程式的入口點。 // #include <iostream> #include <fstream> #include <iomanip> using namespace std; #define

作業系統之動態分割槽分配演算法

class Link{ class Block{ private int number; private char course; private int size; private int begin; boolean flag; Block next; public Bloc

【作業系統總結】動態分割槽分配演算法

基於順序搜尋的動態分割槽分配演算法首次適應演算法（FF）空閒分割槽排成一個鏈，從鏈首開始查詢，知道找到一個大小能滿足的要求的分割槽為止。迴圈首次適應NF 不是每次都是從鏈首查詢，而是從上次找到的空閒分割槽開始查詢，找到下一個能滿足要求的空閒

【C語言】動態記憶體分配（malloc,realloc,calloc,free）的基本理解和區別

#include<Windows.h> #include<stdio.h> #include<malloc.h> int main() { int* p = NULL; printf("%x\n", p); p = (int*)malloc(sizeof(int)*

C語言之動態記憶體分配與釋放

一，堆記憶體 1,堆記憶體特點堆記憶體可以存放任意型別的資料，但需要自己申請與釋放。 2，堆大小堆大小，想像中的無窮大，但實際使用中，受限於實際記憶體的大小和記憶體是否有連續性。二，堆記憶體的申請與釋放 1，malloc函式

實驗四動態分割槽分配演算法

一、需求分析說明程式設計的任務和目的，明確規定下述內容：加深對動態分割槽分配演算法的理解，進一步掌握首次適應演算法、迴圈首次適應演算法、最佳適應演算法和最壞適應演算法的實現方法。 (1) 輸入的形式和輸入值的範圍；已在程式中預置好記憶體和程序等資訊 (2

作業系統可變分割槽用C語言實現按首次適應演算法分配記憶體

每個分割槽有4個數據項，起始地址，大小，狀態，程序號，其實地址和大小以KB為單位，狀態分為“已分”或“空閒”，程序號：若分割槽是已分，則填上此分割槽的程序號，若分割槽是空閒，則填入？這裡先採用首次適應演算法，首次適應演算法是將空閒區按起始地址從小到大排序後，

作業系統可變分割槽用C語言實現按最佳適應演算法分配記憶體

類似上一篇部落格，在分配記憶體使用最佳使用演算法，即將空閒區按大小進行排序實現 #include<stdio.h> #include<stdlib.h> #include<string.h> typedef struc

C語言之動態分配內存

第一個元素 sprint 擴大 for 可選 key 。。 css text 1. malloc()函數和free()函數首先，我們應該知道。所有的程序都必須留出足夠的內存空間來存儲所使用的數據，所以我們常常會預先給程序開辟好內存空間，然後進行操作，

數據結構基礎（1）--數組C語言實現--動態內存分配

ins post cli itl ini sem pri 應該 insert 數據結構基礎（1）--數組C語言實現--動態內存分配基本思想：數組是最常用的數據結構，在內存中連續存儲，可以靜態初始化（int a[2]={1,2}），可以動態初始化 malloc（）。

C語言中動態內存的分配

成功 col 釋放內存否則 turn stdlib.h color span 數組名動態內存分配：根據需要隨時開辟，隨時釋放的內存分配方式。分配時機和釋放時機完全由程序員決定，由於沒有數據聲明，這部分空間沒有名字。無法像使用變量或數組那樣通過變量名或數組名引用其中的數據

c語言獲得動態分配記憶體後的陣列記憶體大小

c語言獲得動態分配記憶體後的陣列記憶體大小用一個函式：_msize(); ★注意：該函式為Windows獨有★ int* s = (int*)malloc(sizeof(int)); int i; for(i

懶癌晚期學圖論的時候自己用C語言寫了個求可達性矩陣的演算法~

可達性矩陣演算法~ 直接上程式碼 #include <iostream> #include <cstring> using namespace std; #define n 5 void print(int a[n][n]); void print1(int a[n][n]); v

C語言寫的作業系統短作業優先演算法

短作業優先的演算法思想：通過對執行時間的排序然後比較，執行時間短的程序優先執行，第一個程序的開始時間等於到達時間，完成時間=開始時間+服務時間，當下一個程序的開始時間>=該程序的完成時間時，下一個程序的開始時間=上一個程序的完成時間，週轉時間和帶權週轉時

C語言中動態分配陣列

摘要的重要性是不言而喻的，每次發文章我都很糾結如何寫出一個有特色的摘要來，能夠以最為簡短的文字向讀者描述出我所要表達的東西。但是常常出現的問題是，摘要寫得太簡短了，讀者看了不清楚文章究竟要講啥；摘要寫得稍微長點的話自然能夠描述清楚所要表達的東西，但是卻也出現了另外一個問題，

純c語言寫動態分割槽分配演算法的FirstFit和BestFit

主要參考連結：

相關推薦