Adjacency List Graph - Problem

Implement a graph using an adjacency list representation. Your implementation should support the following operations:

addVertex(vertex) - Add a new vertex to the graph
addEdge(v1, v2) - Add an edge between two vertices
removeVertex(vertex) - Remove a vertex and all its connections
removeEdge(v1, v2) - Remove the edge between two vertices
display() - Return the adjacency list representation as a dictionary/map

The graph should be undirected, meaning if there's an edge from A to B, there's also an edge from B to A.

Given a list of operations, execute them and return the final adjacency list.

Input & Output

Example 1 — Basic Graph Operations

$ Input: operations = [["addVertex", "A"], ["addVertex", "B"], ["addEdge", "A", "B"], ["display"]]

› Output: {"A": ["B"], "B": ["A"]}

💡 Note: Add vertices A and B, create edge A-B. Since graph is undirected, both A has neighbor B and B has neighbor A.

Example 2 — Remove Operations

$ Input: operations = [["addVertex", "A"], ["addVertex", "B"], ["addVertex", "C"], ["addEdge", "A", "B"], ["addEdge", "B", "C"], ["removeEdge", "A", "B"]]

› Output: {"A": [], "B": ["C"], "C": ["B"]}

💡 Note: Create A-B-C path, then remove A-B edge. Result: A has no neighbors, B-C edge remains intact.

Example 3 — Remove Vertex

$ Input: operations = [["addVertex", "A"], ["addVertex", "B"], ["addVertex", "C"], ["addEdge", "A", "B"], ["addEdge", "B", "C"], ["removeVertex", "B"]]

› Output: {"A": [], "C": []}

💡 Note: Remove vertex B removes all its edges. A and C remain but lose their connections to B.

Constraints

1 ≤ operations.length ≤ 1000
Each operation is one of: addVertex, addEdge, removeVertex, removeEdge
Vertex names can be strings or numbers
Graph is undirected

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 f Facebook 22 M Microsoft 18

The key insight is using a HashMap for direct vertex access instead of scanning edge lists. Each vertex maps to its neighbor list, enabling O(1) lookups. Best approach uses adjacency list with HashMap: Time O(V + E), Space O(V + E).

Common Approaches

✓ Brute Force - Edge List

⏱️ Time: O(E²) Space: O(E)

Maintain a list of all edges as pairs. For each operation, scan through the entire edge list to find relevant connections. This requires checking every edge for vertex operations.

Optimized - Direct Adjacency List

⏱️ Time: O(V + E) Space: O(V + E)

Maintain a HashMap where each vertex maps to its list of neighbors. This allows direct access to any vertex's connections without scanning through all edges.

Brute Force - Edge List — Algorithm Steps

Store all edges as (v1, v2) pairs in a list
For each query, scan entire edge list
For removals, scan and filter the list

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Edges

Maintain list of all edges as pairs

Scan for Operations

Search entire edge list for each query

Rebuild List

Filter and recreate edge list for removals

Code -

solution.c — C

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

typedef struct Edge {
    char v1[20];
    char v2[20];
} Edge;

typedef struct {
    char vertices[100][20];
    int vertexCount;
    Edge edges[1000];
    int edgeCount;
} Graph;

void solution(char operations[][100], int opCount) {
    Graph g = {0};
    
    // Simple implementation for demonstration
    printf("{}");
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Simple parsing would go here
    char operations[100][100];
    int opCount = 0;
    
    solution(operations, opCount);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(E²)

Each operation potentially scans all E edges, and we have E operations

✓ Linear Growth

Space Complexity

O(E)

Store list of edges, each edge stored once

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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

Adjacency List Graph - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Edge List — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler