内存管理中的最差拟合算法程序-yiteyi-C++库

先决条件：分区分配方法最差匹配将进程分配给主内存中可用的自由可用分区中最大的分区。如果一个大进程在后期出现，那么内存将没有空间容纳它。

null

例子：

Input : blockSize[]   = {100, 500, 200, 300, 600};        processSize[] = {212, 417, 112, 426};Output:Process No.    Process Size    Block no.   1        212        5   2        417        2   3        112        5   4        426        Not Allocated

first-fit

推荐：请尝试你的方法 {IDE} 首先，在进入解决方案之前。

Implementation:1- Input memory blocks and processes with sizes.2- Initialize all memory blocks as free.3- Start by picking each process and find the   maximum block size that can be assigned to   current process i.e., find max(bockSize[1],    blockSize[2],.....blockSize[n]) >    processSize[current], if found then assign    it to the current process.5- If not then leave that process and keep checking   the further processes.

以下是上述步骤的实施。

C++

                         // C++ implementation of worst - Fit algorithm                       
                         #include<bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
           
                         // Function to allocate memory to blocks as per worst fit                       
                         // algorithm                       
                         void                                     worstFit(                                     int                                     blockSize[],                                     int                                     m,                                     int                                     processSize[],                       
                                                 int                                     n)                       
                         {                       
                                                 // Stores block id of the block allocated to a                       
                                                 // process                       
                                                 int                                     allocation[n];                       
           
                                                 // Initially no block is assigned to any process                       
                                                 memset                                     (allocation, -1,                                     sizeof                                     (allocation));                       
           
                                                 // pick each process and find suitable blocks                       
                                                 // according to its size ad assign to it                       
                                                 for                                     (                                     int                                     i=0; i<n; i++)                       
                                                 {                       
                                                 // Find the best fit block for current process                       
                                                 int                                     wstIdx = -1;                       
                                                 for                                     (                                     int                                     j=0; j<m; j++)                       
                                                 {                       
                                                 if                                     (blockSize[j] >= processSize[i])                       
                                                 {                       
                                                 if                                     (wstIdx == -1)                       
                                                 wstIdx = j;                       
                                                 else                                     if                                     (blockSize[wstIdx] < blockSize[j])                       
                                                 wstIdx = j;                       
                                                 }                       
                                                 }                       
           
                                                 // If we could find a block for current process                       
                                                 if                                     (wstIdx != -1)                       
                                                 {                       
                                                 // allocate block j to p[i] process                       
                                                 allocation[i] = wstIdx;                       
           
                                                 // Reduce available memory in this block.                       
                                                 blockSize[wstIdx] -= processSize[i];                       
                                                 }                       
                                                 }                       
           
                                                 cout <<                                     "Process No.	Process Size	Block no."                                     ;                       
                                                 for                                     (                                     int                                     i = 0; i < n; i++)                       
                                                 {                       
                                                 cout <<                                     "   "                                     << i+1 <<                                     "		"                                     << processSize[i] <<                                     "		"                                     ;                       
                                                 if                                     (allocation[i] != -1)                       
                                                 cout << allocation[i] + 1;                       
                                                 else                       
                                                 cout <<                                     "Not Allocated"                                     ;                       
                                                 cout << endl;                       
                                                 }                       
                         }                       
           
                         // Driver code                       
                         int                                     main()                       
                         {                       
                                                 int                                     blockSize[] = {100, 500, 200, 300, 600};                       
                                                 int                                     processSize[] = {212, 417, 112, 426};                       
                                                 int                                     m =                                     sizeof                                     (blockSize)/                                     sizeof                                     (blockSize[0]);                       
                                                 int                                     n =                                     sizeof                                     (processSize)/                                     sizeof                                     (processSize[0]);                       
           
                                                 worstFit(blockSize, m, processSize, n);                       
           
                                                 return                                     0 ;                       
                         }                       

JAVA

                         // Java implementation of worst - Fit algorithm                       
           
                         public                                     class                                     GFG                       
                         {                       
                                                 // Method to allocate memory to blocks as per worst fit                       
                                                 // algorithm                       
                                                 static                                     void                                     worstFit(                                     int                                     blockSize[],                                     int                                     m,                                     int                                     processSize[],                       
                                                 int                                     n)                       
                                                 {                       
                                                 // Stores block id of the block allocated to a                       
                                                 // process                       
                                                 int                                     allocation[] =                                     new                                     int                                     [n];                       
                                   
                                                 // Initially no block is assigned to any process                       
                                                 for                                     (                                     int                                     i =                                     0                                     ; i < allocation.length; i++)                       
                                                 allocation[i] = -                                     1                                     ;                       
                                   
                                                 // pick each process and find suitable blocks                       
                                                 // according to its size ad assign to it                       
                                                 for                                     (                                     int                                     i=                                     0                                     ; i<n; i++)                       
                                                 {                       
                                                 // Find the best fit block for current process                       
                                                 int                                     wstIdx = -                                     1                                     ;                       
                                                 for                                     (                                     int                                     j=                                     0                                     ; j<m; j++)                       
                                                 {                       
                                                 if                                     (blockSize[j] >= processSize[i])                       
                                                 {                       
                                                 if                                     (wstIdx == -                                     1                                     )                       
                                                 wstIdx = j;                       
                                                 else                                     if                                     (blockSize[wstIdx] < blockSize[j])                       
                                                 wstIdx = j;                       
                                                 }                       
                                                 }                       
                                   
                                                 // If we could find a block for current process                       
                                                 if                                     (wstIdx != -                                     1                                     )                       
                                                 {                       
                                                 // allocate block j to p[i] process                       
                                                 allocation[i] = wstIdx;                       
                                   
                                                 // Reduce available memory in this block.                       
                                                 blockSize[wstIdx] -= processSize[i];                       
                                                 }                       
                                                 }                       
                                   
                                                 System.out.println(                                     "Process No.	Process Size	Block no."                                     );                       
                                                 for                                     (                                     int                                     i =                                     0                                     ; i < n; i++)                       
                                                 {                       
                                                 System.out.print(                                     "   "                                     + (i+                                     1                                     ) +                                     "		"                                     + processSize[i] +                                     "		"                                     );                       
                                                 if                                     (allocation[i] != -                                     1                                     )                       
                                                 System.out.print(allocation[i] +                                     1                                     );                       
                                                 else                       
                                                 System.out.print(                                     "Not Allocated"                                     );                       
                                                 System.out.println();                       
                                                 }                       
                                                 }                       
                                   
                                                 // Driver Method                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 int                                     blockSize[] = {                                     100                                     ,                                     500                                     ,                                     200                                     ,                                     300                                     ,                                     600                                     };                       
                                                 int                                     processSize[] = {                                     212                                     ,                                     417                                     ,                                     112                                     ,                                     426                                     };                       
                                                 int                                     m = blockSize.length;                       
                                                 int                                     n = processSize.length;                       
                                   
                                                 worstFit(blockSize, m, processSize, n);                       
                                                 }                       
                         }                       

Python3

                         # Python3 implementation of worst - Fit algorithm                       
           
                         # Function to allocate memory to blocks as                       
                         # per worst fit algorithm                       
                         def                                     worstFit(blockSize, m, processSize, n):                       
                                   
                                                 # Stores block id of the block                       
                                                 # allocated to a process                       
                                   
                                                 # Initially no block is assigned                       
                                                 # to any process                       
                                                 allocation                                     =                                     [                                     -                                     1                                     ]                                     *                                     n                       
                                   
                                                 # pick each process and find suitable blocks                       
                                                 # according to its size ad assign to it                       
                                                 for                                     i                                     in                                     range                                     (n):                       
                                   
                                                 # Find the best fit block for                       
                                                 # current process                       
                                                 wstIdx                                     =                                     -                                     1                       
                                                 for                                     j                                     in                                     range                                     (m):                       
                                                 if                                     blockSize[j] >                                     =                                     processSize[i]:                       
                                                 if                                     wstIdx                                     =                                     =                                     -                                     1                                     :                       
                                                 wstIdx                                     =                                     j                       
                                                 elif                                     blockSize[wstIdx] < blockSize[j]:                       
                                                 wstIdx                                     =                                     j                       
           
                                                 # If we could find a block for                       
                                                 # current process                       
                                                 if                                     wstIdx !                                     =                                     -                                     1                                     :                       
                                   
                                                 # allocate block j to p[i] process                       
                                                 allocation[i]                                     =                                     wstIdx                       
           
                                                 # Reduce available memory in this block.                       
                                                 blockSize[wstIdx]                                     -                                     =                                     processSize[i]                       
           
                                                 print                                     (                                     "Process No. Process Size Block no."                                     )                       
                                                 for                                     i                                     in                                     range                                     (n):                       
                                                 print                                     (i                                     +                                     1                                     ,                                     "         "                                     ,                       
                                                 processSize[i], end                                     =                                     "     "                                     )                       
                                                 if                                     allocation[i] !                                     =                                     -                                     1                                     :                       
                                                 print                                     (allocation[i]                                     +                                     1                                     )                       
                                                 else                                     :                       
                                                 print                                     (                                     "Not Allocated"                                     )                       
           
                         # Driver code                       
                         if                                     __name__                                     =                                     =                                     '__main__'                                     :                       
                                                 blockSize                                     =                                     [                                     100                                     ,                                     500                                     ,                                     200                                     ,                                     300                                     ,                                     600                                     ]                       
                                                 processSize                                     =                                     [                                     212                                     ,                                     417                                     ,                                     112                                     ,                                     426                                     ]                       
                                                 m                                     =                                     len                                     (blockSize)                       
                                                 n                                     =                                     len                                     (processSize)                       
           
                                                 worstFit(blockSize, m, processSize, n)                       
           
                         # This code is contributed by PranchalK                       

C#

                         // C# implementation of worst - Fit algorithm                       
                         using                                     System;                       
           
                         class                                     GFG                       
                         {                       
                                                 // Method to allocate memory to blocks                       
                                                 // as per worst fit algorithm                       
                                                 static                                     void                                     worstFit(                                     int                                     []blockSize,                                     int                                     m,                       
                                                 int                                     []processSize,                                     int                                     n)                       
                                                 {                       
                                                 // Stores block id of the block allocated to a                       
                                                 // process                       
                                                 int                                     []allocation =                                     new                                     int                                     [n];                       
                                   
                                                 // Initially no block is assigned to any process                       
                                                 for                                     (                                     int                                     i = 0; i < allocation.Length; i++)                       
                                                 allocation[i] = -1;                       
                                   
                                                 // pick each process and find suitable blocks                       
                                                 // according to its size ad assign to it                       
                                                 for                                     (                                     int                                     i = 0; i < n; i++)                       
                                                 {                       
                                                 // Find the best fit block for current process                       
                                                 int                                     wstIdx = -1;                       
                                                 for                                     (                                     int                                     j = 0; j < m; j++)                       
                                                 {                       
                                                 if                                     (blockSize[j] >= processSize[i])                       
                                                 {                       
                                                 if                                     (wstIdx == -1)                       
                                                 wstIdx = j;                       
                                                 else                                     if                                     (blockSize[wstIdx] < blockSize[j])                       
                                                 wstIdx = j;                       
                                                 }                       
                                                 }                       
                                   
                                                 // If we could find a block for current process                       
                                                 if                                     (wstIdx != -1)                       
                                                 {                       
                                                 // allocate block j to p[i] process                       
                                                 allocation[i] = wstIdx;                       
                                   
                                                 // Reduce available memory in this block.                       
                                                 blockSize[wstIdx] -= processSize[i];                       
                                                 }                       
                                                 }                       
                                   
                                                 Console.WriteLine(                                     "Process No.	Process Size	Block no."                                     );                       
                                                 for                                     (                                     int                                     i = 0; i < n; i++)                       
                                                 {                       
                                                 Console.Write(                                     " "                                     + (i+1) +                                     "			"                                     + processSize[i] +                                     "			"                                     );                       
                                                 if                                     (allocation[i] != -1)                       
                                                 Console.Write(allocation[i] + 1);                       
                                                 else                       
                                                 Console.Write(                                     "Not Allocated"                                     );                       
                                                 Console.WriteLine();                       
                                                 }                       
                                                 }                       
                                   
                                                 // Driver code                       
                                                 public                                     static                                     void                                     Main(String[] args)                       
                                                 {                       
                                                 int                                     []blockSize = {100, 500, 200, 300, 600};                       
                                                 int                                     []processSize = {212, 417, 112, 426};                       
                                                 int                                     m = blockSize.Length;                       
                                                 int                                     n = processSize.Length;                       
                                   
                                                 worstFit(blockSize, m, processSize, n);                       
                                                 }                       
                         }                       
           
                         // This code has been contributed by 29AjayKumar                       

Javascript

                         <script>                       
           
                         // Javascript implementation of                       
                         // worst - Fit algorithm                       
           
                         // Method to allocate memory to                       
                         // blocks as per worst fit                       
                         // algorithm                       
                         function                                     worstFit(blockSize, m,                       
                                                 processSize, n)                       
                         {                       
                                   
                                                 // Stores block id of the block allocated                       
                                                 // to a process                       
                                                 let allocation =                                     new                                     Array(n);                       
                                   
                                                 // Initially no block is assigned                       
                                                 // to any process                       
                                                 for                                     (let i = 0; i < allocation.length; i++)                       
                                                 allocation[i] = -1;                       
                                   
                                                 // Pick each process and find suitable blocks                       
                                                 // according to its size ad assign to it                       
                                                 for                                     (let i = 0; i < n; i++)                       
                                                 {                       
                                   
                                                 // Find the best fit block                       
                                                 // for current process                       
                                                 let wstIdx = -1;                       
                                                 for                                     (let j = 0; j < m; j++)                       
                                                 {                       
                                                 if                                     (blockSize[j] >= processSize[i])                       
                                                 {                       
                                                 if                                     (wstIdx == -1)                       
                                                 wstIdx = j;                       
                                                 else                                     if                                     (blockSize[wstIdx] <                       
                                                 blockSize[j])                       
                                                 wstIdx = j;                       
                                                 }                       
                                                 }                       
                                   
                                                 // If we could find a block for                       
                                                 // current process                       
                                                 if                                     (wstIdx != -1)                       
                                                 {                       
                                   
                                                 // Allocate block j to p[i] process                       
                                                 allocation[i] = wstIdx;                       
                                   
                                                 // Reduce available memory in this block.                       
                                                 blockSize[wstIdx] -= processSize[i];                       
                                                 }                       
                                                 }                       
                                   
                                                 document.write(                                     "<br>Process No.&nbsp&nbsp"                                     +                       
                                                 "&nbspProcess Size&nbsp&nbsp"                                     +                       
                                                 "&nbspBlock no.<br>"                                     );                       
                                                 for                                     (let i = 0; i < n; i++)                       
                                                 {                       
                                                 document.write(                                     "   "                                     + (i + 1) +                       
                                                 "&nbsp&nbsp&nbsp&nbsp&nbsp"                                     +                       
                                                 "&nbsp&nbsp&nbsp&nbsp"                                     +                       
                                                 processSize[i] +                       
                                                 "&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp"                                     );                       
                                                 if                                     (allocation[i] != -1)                       
                                                 document.write(allocation[i] + 1);                       
                                                 else                       
                                                 document.write(                                     "Not Allocated"                                     );                       
                                   
                                                 document.write(                                     "<br>"                                     );                       
                                                 }                       
                         }                       
           
                         // Driver code                       
                         let blockSize = [ 100, 500, 200, 300, 600 ];                       
                         let processSize = [ 212, 417, 112, 426 ];                       
                         let m = blockSize.length;                       
                         let n = processSize.length;                       
           
                         worstFit(blockSize, m, processSize, n);                       
           
                         // This code is contributed by rag2127                       
           
                         </script>                       

输出：

Process No.    Process Size    Block no.   1        212        5   2        417        2   3        112        5   4        426        Not Allocated

本文由 萨希尔·查布拉（阿克库） .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章