First Fit algorithm in Memory Management using Linked List

// Java implementation of the First
// sit memory management algorithm
// using linked list

public class GFG {

    // Two global counters
    static int g = 0, k = 0;

    // Structure for free list
    static class free {
        int tag;
        int size;
        free next;
    }
    static free free_head = null;
    static free prev_free = null;

    // Structure for allocated list
    static class alloc {
        int block_id;
        int tag;
        int size;
        alloc next;
    }
    static alloc alloc_head = null;
    static alloc prev_alloc = null;

    // Function to create free
    // list with given sizes
    static void create_free(int c)
    {
        free p = new free();
        p.size = c;
        p.tag = g;
        p.next = null;
        if (free_head == null)
            free_head = p;
        else
            prev_free.next = p;
        prev_free = p;
        g++;
    }

    // Function to print free list which
    // prints free blocks of given sizes
    static void print_free()
    {
        free p = free_head;
        System.out.println("Tag\tSize");
        while (p != null) {
            System.out.println(p.tag + "\t" + p.size);
            p = p.next;
        }
    }

    // Function to print allocated list which
    // prints allocated blocks and their block ids
    static void print_alloc()
    {
        alloc p = alloc_head;
        System.out.println("Tag\tBlock ID\tSize");
        while (p != null) {
            System.out.println(p.tag + "\t " + p.block_id
                               + "\t\t" + p.size);
            p = p.next;
        }
    }

    // Function to allocate memory to
    // blocks as per First fit algorithm
    static void create_alloc(int c)
    {
        // create node for process of given size
        alloc q = new alloc();
        q.size = c;
        q.tag = k;
        q.next = null;
        free p = free_head;

        // Iterate to find first memory
        // block with appropriate size
        while (p != null) {
            if (q.size <= p.size)
                break;
            p = p.next;
        }

        // Node found to allocate
        if (p != null) {
            // Adding node to allocated list
            q.block_id = p.tag;
            p.size -= q.size;
            if (alloc_head == null)
                alloc_head = q;
            else {
                prev_alloc = alloc_head;
                while (prev_alloc.next != null)
                    prev_alloc = prev_alloc.next;
                prev_alloc.next = q;
            }
            k++;
        }
        else // Node found to allocate space from
            System.out.println("Block of size " + c
                               + " can't be allocated");
    }

    // Function to delete node from
    // allocated list to free some space
    static void delete_alloc(int t)
    {
        // Standard delete function
        // of a linked list node
        alloc p = alloc_head, q = null;

        // First, find the node according
        // to given tag id
        while (p != null) {
            if (p.tag == t)
                break;
            q = p;
            p = p.next;
        }
        if (p == null)
            System.out.println("Tag ID doesn't exist");
        else if (p == alloc_head)
            alloc_head = alloc_head.next;
        else
            q.next = p.next;
        free temp = free_head;
        while (temp != null) {
            if (temp.tag == p.block_id) {
                temp.size += p.size;
                break;
            }
            temp = temp.next;
        }
    }

    // Driver Code
    public static void main(String[] args)
    {
        int blockSize[] = { 100, 500, 200 };
        int processSize[] = { 417, 112, 426, 95 };
        int m = blockSize.length;
        int n = processSize.length;

        for (int i = 0; i < m; i++)
            create_free(blockSize[i]);

        for (int i = 0; i < n; i++)
            create_alloc(processSize[i]);

        print_alloc();

        // Block of tag id 0 deleted
        // to free space for block of size 426
        delete_alloc(0);

        create_alloc(426);
        System.out.println("After deleting block"
                           + " with tag id 0.");
        print_alloc();
    }
}

// This code is contributed by Lovely Jain