Custom Allocator with Coalescing - Problem

Design and implement a custom memory allocator that supports dynamic memory allocation and deallocation with block coalescing. Your allocator should manage a contiguous block of memory and provide two allocation strategies: first-fit and best-fit.

The allocator should maintain a free list of available memory blocks and automatically coalesce adjacent free blocks when memory is deallocated to prevent fragmentation.

Implement the following methods:

Allocator(size) - Initialize allocator with given memory size
allocate(size, strategy) - Allocate memory using 'first-fit' or 'best-fit' strategy. Returns start address or -1 if allocation fails
deallocate(address, size) - Free memory block and coalesce adjacent free blocks
getFragmentation() - Return number of free blocks (measures fragmentation)

The input consists of operations to perform on the allocator. Each operation is represented as an array where the first element is the operation type.

Input & Output

Example 1 — Basic Allocation and Deallocation

$ Input: memorySize = 1000, operations = [["allocate",100,"first-fit"],["allocate",200,"best-fit"],["deallocate",0,100],["getFragmentation"]]

› Output: [0,100,3]

💡 Note: Allocate 100B at address 0, then 200B at address 100. After deallocating first block and coalescing, we have 3 free blocks total.

Example 2 — Best-fit vs First-fit Strategy

$ Input: memorySize = 500, operations = [["allocate",100,"first-fit"],["allocate",50,"best-fit"],["getFragmentation"]]

› Output: [0,100,2]

💡 Note: First-fit allocates 100B at start. Best-fit finds the smallest suitable block for 50B allocation.

Example 3 — Coalescing Adjacent Blocks

$ Input: memorySize = 300, operations = [["allocate",100,"first-fit"],["allocate",100,"first-fit"],["deallocate",0,100],["deallocate",100,100],["getFragmentation"]]

› Output: [0,100,1]

💡 Note: After deallocating adjacent blocks, they coalesce into a single 300B free block.

Constraints

1 ≤ memorySize ≤ 10⁶
1 ≤ operations.length ≤ 1000
1 ≤ allocation size ≤ memorySize
strategy ∈ {"first-fit", "best-fit"}

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Meta 28

The key insight is to maintain sorted free lists for efficient allocation strategies and implement proper coalescing to prevent fragmentation. The optimal approach uses sorted data structures for O(log n) allocation time and efficient memory management. Time: O(log n) per operation, Space: O(n) for free lists.

Common Approaches

✓ Linear Search with Basic Coalescing

⏱️ Time: O(n) Space: O(n)

Maintain memory as a list of blocks, scan linearly for allocation, and perform basic coalescing by checking immediate neighbors when deallocating.

Sorted Free List with Efficient Coalescing

⏱️ Time: O(log n) Space: O(n)

Use separate sorted lists for free blocks (by size for best-fit, by address for coalescing) to achieve faster allocation and more efficient memory management.

Linear Search with Basic Coalescing — Algorithm Steps

Scan all blocks linearly for allocation
For first-fit: return first suitable block
For best-fit: scan all blocks and pick smallest suitable
On deallocation: merge with adjacent free blocks

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan Blocks

Iterate through all memory blocks linearly

Find Suitable

Check if block is free and large enough

Allocate & Split

Mark block as allocated, split if necessary

Code -

solution.c — C

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

typedef struct MemoryBlock {
    int start;
    int size;
    bool isFree;
    struct MemoryBlock* next;
} MemoryBlock;

typedef struct {
    MemoryBlock* head;
    int memorySize;
} Allocator;

Allocator* createAllocator(int size) {
    Allocator* allocator = malloc(sizeof(Allocator));
    allocator->memorySize = size;
    allocator->head = malloc(sizeof(MemoryBlock));
    allocator->head->start = 0;
    allocator->head->size = size;
    allocator->head->isFree = true;
    allocator->head->next = NULL;
    return allocator;
}

int allocate(Allocator* allocator, int size, const char* strategy) {
    MemoryBlock* current = allocator->head;
    MemoryBlock* selected = NULL;
    
    // Find suitable block
    while (current) {
        if (current->isFree && current->size >= size) {
            if (strcmp(strategy, "first-fit") == 0) {
                selected = current;
                break;
            } else { // best-fit
                if (!selected || current->size < selected->size) {
                    selected = current;
                }
            }
        }
        current = current->next;
    }
    
    if (!selected) return -1;
    
    if (selected->size == size) {
        selected->isFree = false;
    } else {
        // Split block
        MemoryBlock* newBlock = malloc(sizeof(MemoryBlock));
        newBlock->start = selected->start + size;
        newBlock->size = selected->size - size;
        newBlock->isFree = true;
        newBlock->next = selected->next;
        
        selected->size = size;
        selected->isFree = false;
        selected->next = newBlock;
    }
    
    return selected->start;
}

void deallocate(Allocator* allocator, int address, int size) {
    MemoryBlock* current = allocator->head;
    
    // Find and free the block
    while (current) {
        if (current->start == address && current->size == size) {
            current->isFree = true;
            break;
        }
        current = current->next;
    }
    
    // Simple coalescing with next block
    current = allocator->head;
    while (current && current->next) {
        if (current->isFree && current->next->isFree && 
            current->start + current->size == current->next->start) {
            MemoryBlock* toDelete = current->next;
            current->size += toDelete->size;
            current->next = toDelete->next;
            free(toDelete);
        } else {
            current = current->next;
        }
    }
}

int getFragmentation(Allocator* allocator) {
    int count = 0;
    MemoryBlock* current = allocator->head;
    while (current) {
        if (current->isFree) count++;
        current = current->next;
    }
    return count;
}

int* solution(int memorySize, int numOps, int* resultSize) {
    Allocator* allocator = createAllocator(memorySize);
    int* results = malloc(numOps * sizeof(int));
    int resultCount = 0;
    
    // Simplified - would need proper operation parsing
    // For demonstration, assume we have parsed operations
    
    *resultSize = resultCount;
    return results;
}

int main() {
    int memorySize;
    scanf("%d", &memorySize);
    
    int resultSize;
    int* result = solution(memorySize, 0, &resultSize);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        printf("%d", result[i]);
        if (i < resultSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Linear scan through all memory blocks for each allocation

✓ Linear Growth

Space Complexity

O(n)

Store list of memory blocks

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Custom Allocator with Coalescing - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Linear Search with Basic Coalescing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler