Codestin Search App

Design In-Memory File System - Problem

🗂️ Design In-Memory File System

Imagine you're building a cloud storage system that needs to simulate a complete file system entirely in memory. You need to create a data structure that can handle all the basic operations you'd expect from a real file system: listing directories, creating folders, writing files, and reading their contents.

Your FileSystem class should support these operations:

List Directory/File (ls): Given a path, return all files and folders in lexicographic order. If it's a file, return just that filename.
Create Directory (mkdir): Create a new directory (and any missing parent directories) at the given path.
Write/Append to File (addContentToFile): Create a new file with content, or append to existing file content.
Read File (readContentFromFile): Return the complete content of a file.

Think of it like implementing your own version of a simplified Unix file system commands!

Input & Output

Basic Operations

$ Input: fs = FileSystem() fs.ls("/") # [] fs.mkdir("/a/b/c") fs.addContentToFile("/a/b/c/d", "hello") fs.ls("/") # ["a"] fs.readContentFromFile("/a/b/c/d") # "hello"

› Output: [] ["a"] "hello"

💡 Note: Create directory structure, add file with content, then list and read operations work correctly

File vs Directory Listing

$ Input: fs = FileSystem() fs.addContentToFile("/goowmfn", "c") fs.ls("/goowmfn") # ["goowmfn"] fs.ls("/") # ["goowmfn"]

› Output: ["goowmfn"] ["goowmfn"]

💡 Note: When ls() is called on a file path, it returns just the filename. When called on directory containing that file, it lists the file.

Content Appending

$ Input: fs = FileSystem() fs.addContentToFile("/a", "hello") fs.addContentToFile("/a", " world") fs.readContentFromFile("/a") # "hello world"

› Output: "hello world"

💡 Note: Multiple calls to addContentToFile append content to existing files rather than overwriting

Constraints

1 ≤ path.length, filePath.length ≤ 100
1 ≤ content.length ≤ 50
All paths are absolute paths starting with '/' and do not end with '/' except for root
At most 300 calls will be made to the methods
File and directory names consist of only lowercase English letters and digits

Visualization

Tap to expand

Understanding the Visualization

Root Foundation

Start with root node (/) as the foundation of our file system tree

Branch Navigation

Each path component leads us down a specific branch in the tree

Efficient Access

Operations only traverse the path depth, not the entire file system

Key Takeaway

🎯 Key Insight: By representing the file system as a tree where each node is a directory containing files and subdirectories, we achieve O(path_depth) complexity for all operations - much faster than linear searching through all paths.

Asked in

The optimal solution uses a Trie-like tree structure where each node represents a directory containing maps for subdirectories and files. This enables O(path_depth) operations instead of linear searches, making it efficient for large file systems while naturally representing the hierarchical structure.

Common Approaches

Approach	Time	Space	Notes
✓ Trie-Based File System (Optimal)	O(L)	O(N * L)	Use a Trie-like tree structure where each node represents a directory with files and subdirectories
Brute Force (Linear Search)	O(n)	O(n * L)	Store all paths as strings in lists and search linearly for operations

Trie-Based File System (Optimal) — Algorithm Steps

Create a TrieNode class with maps for subdirectories and files
Root node represents the filesystem root '/'
For mkdir: traverse path and create missing directory nodes
For file operations: navigate to parent directory and add/update file
For ls: return sorted list of files and subdirectories at the target node

Visualization

Tap to expand

Step-by-Step Walkthrough

Tree Structure

Each node represents a directory with files and subdirectory pointers

Path Navigation

Navigate down tree following path components - O(path_length)

Efficient Operations

All operations work directly on the target node without scanning

Code -

solution.c — C

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

#define MAX_NAME_LEN 64
#define MAX_CONTENT_LEN 1024
#define MAX_CHILDREN 100

typedef struct TrieNode {
    char dirNames[MAX_CHILDREN][MAX_NAME_LEN];
    struct TrieNode* dirs[MAX_CHILDREN];
    char fileNames[MAX_CHILDREN][MAX_NAME_LEN];
    char fileContents[MAX_CHILDREN][MAX_CONTENT_LEN];
    int dirCount;
    int fileCount;
} TrieNode;

typedef struct {
    TrieNode* root;
} FileSystem;

TrieNode* createTrieNode() {
    TrieNode* node = (TrieNode*)malloc(sizeof(TrieNode));
    node->dirCount = 0;
    node->fileCount = 0;
    return node;
}

FileSystem* fileSystemCreate() {
    FileSystem* fs = (FileSystem*)malloc(sizeof(FileSystem));
    fs->root = createTrieNode();
    return fs;
}

TrieNode* navigateToNode(FileSystem* obj, char* path) {
    if (strcmp(path, "/") == 0) {
        return obj->root;
    }
    
    TrieNode* current = obj->root;
    char* pathCopy = (char*)malloc(strlen(path) + 1);
    strcpy(pathCopy, path);
    
    char* token = strtok(pathCopy + 1, "/");  // Skip first '/'
    while (token != NULL) {
        int found = -1;
        for (int i = 0; i < current->dirCount; i++) {
            if (strcmp(current->dirNames[i], token) == 0) {
                found = i;
                break;
            }
        }
        if (found == -1) {
            free(pathCopy);
            return NULL;
        }
        current = current->dirs[found];
        token = strtok(NULL, "/");
    }
    
    free(pathCopy);
    return current;
}

TrieNode* navigateAndCreate(FileSystem* obj, char* path) {
    if (strcmp(path, "/") == 0) {
        return obj->root;
    }
    
    TrieNode* current = obj->root;
    char* pathCopy = (char*)malloc(strlen(path) + 1);
    strcpy(pathCopy, path);
    
    char* token = strtok(pathCopy + 1, "/");
    while (token != NULL) {
        int found = -1;
        for (int i = 0; i < current->dirCount; i++) {
            if (strcmp(current->dirNames[i], token) == 0) {
                found = i;
                break;
            }
        }
        if (found == -1) {
            strcpy(current->dirNames[current->dirCount], token);
            current->dirs[current->dirCount] = createTrieNode();
            current = current->dirs[current->dirCount];
            current->dirCount++;
        } else {
            current = current->dirs[found];
        }
        token = strtok(NULL, "/");
    }
    
    free(pathCopy);
    return current;
}

char** fileSystemLs(FileSystem* obj, char* path, int* returnSize) {
    // Check if it's a file
    char* lastSlash = strrchr(path, '/');
    if (lastSlash != NULL) {
        char filename[MAX_NAME_LEN];
        strcpy(filename, lastSlash + 1);
        
        char parentPath[256];
        strncpy(parentPath, path, lastSlash - path);
        parentPath[lastSlash - path] = '\0';
        if (strlen(parentPath) == 0) strcpy(parentPath, "/");
        
        TrieNode* parentNode = navigateToNode(obj, parentPath);
        if (parentNode) {
            for (int i = 0; i < parentNode->fileCount; i++) {
                if (strcmp(parentNode->fileNames[i], filename) == 0) {
                    char** result = (char**)malloc(sizeof(char*));
                    result[0] = (char*)malloc(strlen(filename) + 1);
                    strcpy(result[0], filename);
                    *returnSize = 1;
                    return result;
                }
            }
        }
    }
    
    // It's a directory
    TrieNode* node = navigateToNode(obj, path);
    if (!node) {
        *returnSize = 0;
        return NULL;
    }
    
    char** result = (char**)malloc((node->dirCount + node->fileCount) * sizeof(char*));
    *returnSize = 0;
    
    for (int i = 0; i < node->fileCount; i++) {
        result[*returnSize] = (char*)malloc(strlen(node->fileNames[i]) + 1);
        strcpy(result[*returnSize], node->fileNames[i]);
        (*returnSize)++;
    }
    
    for (int i = 0; i < node->dirCount; i++) {
        result[*returnSize] = (char*)malloc(strlen(node->dirNames[i]) + 1);
        strcpy(result[*returnSize], node->dirNames[i]);
        (*returnSize)++;
    }
    
    return result;
}

void fileSystemMkdir(FileSystem* obj, char* path) {
    navigateAndCreate(obj, path);
}

void fileSystemAddContentToFile(FileSystem* obj, char* filePath, char* content) {
    char* lastSlash = strrchr(filePath, '/');
    char filename[MAX_NAME_LEN];
    strcpy(filename, lastSlash + 1);
    
    char parentPath[256];
    strncpy(parentPath, filePath, lastSlash - filePath);
    parentPath[lastSlash - filePath] = '\0';
    if (strlen(parentPath) == 0) strcpy(parentPath, "/");
    
    TrieNode* parentNode = navigateAndCreate(obj, parentPath);
    
    int found = -1;
    for (int i = 0; i < parentNode->fileCount; i++) {
        if (strcmp(parentNode->fileNames[i], filename) == 0) {
            found = i;
            break;
        }
    }
    
    if (found >= 0) {
        strcat(parentNode->fileContents[found], content);
    } else {
        strcpy(parentNode->fileNames[parentNode->fileCount], filename);
        strcpy(parentNode->fileContents[parentNode->fileCount], content);
        parentNode->fileCount++;
    }
}

char* fileSystemReadContentFromFile(FileSystem* obj, char* filePath) {
    char* lastSlash = strrchr(filePath, '/');
    char filename[MAX_NAME_LEN];
    strcpy(filename, lastSlash + 1);
    
    char parentPath[256];
    strncpy(parentPath, filePath, lastSlash - filePath);
    parentPath[lastSlash - filePath] = '\0';
    if (strlen(parentPath) == 0) strcpy(parentPath, "/");
    
    TrieNode* parentNode = navigateToNode(obj, parentPath);
    
    for (int i = 0; i < parentNode->fileCount; i++) {
        if (strcmp(parentNode->fileNames[i], filename) == 0) {
            return parentNode->fileContents[i];
        }
    }
    return NULL;
}

void fileSystemFree(FileSystem* obj) {
    // Recursive cleanup would go here
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(L)

Where L is the length of the path (number of directories in path). Each operation only needs to traverse the path once.

✓ Linear Growth

Space Complexity

O(N * L)

Where N is total number of files/directories and L is average path depth. Shared prefixes save space compared to storing full paths.

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

🗂️ Design In-Memory File System

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Trie-Based File System (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler