Skip to content

Program for Shortest Job First (or SJF) CPU Scheduling | Set 1 (Non- preemptive)

Program for Worst Fit algorithm in Memory Management

Last Updated : 13 Sep, 2023

Prerequisite : Partition allocation methods
Worst Fit allocates a process to the partition which is largest sufficient among the freely available partitions available in the main memory. If a large process comes at a later stage, then memory will not have space to accommodate it.

Example:

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

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.

Below is implementation of above steps.

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 << "\nProcess No.\tProcess Size\tBlock no.\n"; 
    for (int i = 0; i < n; i++) 
    { 
        cout << "   " << i+1 << "\t\t" << processSize[i] << "\t\t"; 
        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("\nProcess No.\tProcess Size\tBlock no."); 
        for (int i = 0; i < n; i++) 
        { 
            System.out.print("   " + (i+1) + "\t\t" + processSize[i] + "\t\t"); 
            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("\nProcess No.\tProcess Size\tBlock no.");  
        for (int i = 0; i < n; i++)  
        {  
            Console.Write(" " + (i+1) + "\t\t\t" + processSize[i] + "\t\t\t");  
            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> 
 
  

Output

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

Time Complexity: O(N*M) where N is processSize length and M is blockSize length.
Auxiliary Space: O(N)

Program for Shortest Job First (or SJF) CPU Scheduling | Set 1 (Non- preemptive)

S

Sahil Chhabra (akku)

Improve

Article Tags :

Practice Tags :

Algorithms

Similar Reads

Greedy Algorithms

Greedy algorithms are a class of algorithms that make locally optimal choices at each step with the hope of finding a global optimum solution. At every step of the algorithm, we make a choice that looks the best at the moment. To make the choice, we sometimes sort the array so that we can always get

Greedy Algorithm Tutorial

Greedy is an algorithmic paradigm that builds up a solution piece by piece, always choosing the next piece that offers the most obvious and immediate benefit. Greedy algorithms are used for optimization problems. An optimization problem can be solved using Greedy if the problem has the following pro

Greedy Algorithms General Structure

A greedy algorithm solves problems by making the best choice at each step. Instead of looking at all possible solutions, it focuses on the option that seems best right now. Problem structure:Most of the problems where greedy algorithms work follow these two properties: 1). Greedy Choice Property:- T

Difference between Greedy Algorithm and Divide and Conquer Algorithm

Greedy algorithm and divide and conquer algorithm are two common algorithmic paradigms used to solve problems. The main difference between them lies in their approach to solving problems. Greedy Algorithm:The greedy algorithm is an algorithmic paradigm that follows the problem-solving heuristic of m

Greedy Approach vs Dynamic programming

Greedy approach and Dynamic programming are two different algorithmic approaches that can be used to solve optimization problems. Here are the main differences between these two approaches: Greedy Approach:The greedy approach makes the best choice at each step with the hope of finding a global optim

Comparison among Greedy, Divide and Conquer and Dynamic Programming algorithm

Greedy algorithm, divide and conquer algorithm, and dynamic programming algorithm are three common algorithmic paradigms used to solve problems. Here's a comparison among these algorithms: Approach:Greedy algorithm: Makes locally optimal choices at each step with the hope of finding a global optimum