Questions
7 of 59
1What is a Graph? Define Vertex, Edge, Degree.
2What is the difference between Directed and Undirected Graphs?
3What is a Weighted Graph?
4What is a Cyclic vs Acyclic Graph?
5What is the difference between a Tree and a Graph?
6Explain Adjacency Matrix. What are its pros and cons?
7Explain Adjacency List. What are its pros and cons?
8Which representation is better for Sparse vs Dense graphs?
9Explain Breadth-First Search (BFS). What data structure does it use?
10Explain Depth-First Search (DFS). What data structure does it use?
11What is the time complexity of BFS and DFS?
12What is Topological Sorting? Which algorithm is used?
13How do you detect a cycle in a Directed Graph?
14How do you detect a cycle in an Undirected Graph?
15Explain Dijkstra's Algorithm. When does it fail?
16Explain Bellman-Ford Algorithm. Why is it slower than Dijkstra?
17What is the difference between Dijkstra and A* (A-star)?
18What is a Minimum Spanning Tree (MST)?
19Explain Kruskal's Algorithm. Which data structure is crucial for it?
20Explain Prim's Algorithm.
21What is the difference between Kruskal's and Prim's? When is one preferred?
22What is Union-Find (Disjoint Set Union)? Explain Path Compression and Union by Rank.
23What is a Bipartite Graph? How do you check for it?
24How do you find the shortest path in an unweighted graph?
25Explain Strongly Connected Components (Kosaraju/Tarjan).
26What is a Directed Acyclic Graph (DAG)? Why are they important in build systems?
27How do you solve a Maze using Graph algorithms?
28Explain Floyd-Warshall Algorithm (All Pairs Shortest Path).
29How do you detect a Deadlock using a Graph?
30What is the difference between Linear Search and Binary Search?
31What is the precondition for Binary Search?
32Write down the time complexities of Bubble, Selection, Insertion Sort.
33Why is Insertion Sort preferred for small or nearly sorted arrays?
34Explain Merge Sort. What is its time and space complexity?
35Explain Quick Sort. What is its worst-case complexity? How do you avoid it?
36Compare Merge Sort vs Quick Sort. When do you choose which?
37What is Heap Sort? How does it work?
38Is Heap Sort stable? Is Merge Sort stable?
39What is Counting Sort? What are its limitations?
40What is Radix Sort? How does it handle strings?
41What is the fastest possible time complexity for a comparison-based sort? Why?
42What is the difference between Internal and External Sorting?
43How do you find the k-th largest element in an array?
44How do you find the median of a stream of numbers?
45What is a Bucket Sort? When is it effective?
46Explain the concept of Stability in sorting. Why does it matter for multi-key sorting?
47What is a Persistent Data Structure?
48What is a Treap? How does it combine BST and Heap properties?
49What is a Bloom Filter? How do you calculate the False Positive rate?
50What is an LRU Cache? How do you implement it using a Hash Map and Doubly Linked List?
51What is an LFU Cache? How is it different from LRU?
52What is a Suffix Tree/Array? What string problems does it solve?
53What is a Van Emde Boas tree?
54How do you design a Data Structure that supports insert, delete, search, and getRandom in O(1)?
55What is the Median of Medians algorithm? Why is it better than random pivot selection?
56Explain the concept of Cache Oblivious algorithms.
57What is the difference between a Binary Heap and a Fibonacci Heap? Why is Fibonacci Heap theoretically faster for Dijkstra's?
58How are Data Structures used in Database Indexing? (B+ Trees, Hash Indexes)
59How does the Garbage Collector interact with data structures? (Weak references, Gen0/Gen1/Gen2)
07 / 59

Explain Adjacency List. What are its pros and cons?

Difficulty: 3/10
graph representation, space complexity, edge operations

Adjacency List

An adjacency list stores, for each vertex, a collection of its neighboring vertices. For weighted graphs, each entry can contain the neighbor and edge weight. It uses O(V+E) space and is usually the preferred representation for sparse graphs and traversal algorithms.

javascript
  1. 1

    Space: O(V+E).

  2. 2

    Neighbor traversal: O(degree(v)).

  3. 3

    Excellent for sparse graphs.

  4. 4

    BFS and DFS naturally operate on adjacency lists.

  5. 5

    Checking whether a specific edge exists may take O(degree(v)).

Scenario Questions

0-2 years experience

  1. 1We need to store a small social network where each user follows a few others. How would you represent this using an adjacency list in code?
  2. 2If you have a graph with five vertices and you add an edge between vertex 2 and vertex 4, what does the adjacency list look like after the insertion?
  3. 3What happens when you iterate over the neighbors of a vertex that currently has no edges?

2-5 years experience

  1. 1Your pathfinding feature uses an adjacency list, but after a data import some nodes have duplicate neighbor entries. How would you detect and clean those duplicates?
  2. 2Checking whether an edge exists between two vertices is slower than expected. Why might an adjacency list cause this, and what alternative representation could you consider?
  3. 3We need to support both directed and undirected graphs with the same codebase. How would you adapt your adjacency list implementation to handle both cases without duplicating logic?

5-8 years experience

  1. 1You are designing a microservice that stores a massive road network (millions of vertices, billions of edges). Explain how you would store the adjacency list on disk and the trade‑offs for read vs. write performance.
  2. 2A memory leak appears when repeatedly adding and removing edges in a long‑running analytics job. Walk through how you would investigate and fix the leak in an adjacency‑list implementation.
  3. 3When scaling the graph to a distributed environment, what challenges arise with an adjacency list, and how would you partition the data to minimize cross‑machine edge lookups?

8+ years experience

  1. 1Our platform is migrating from an in‑memory adjacency list to a persisted graph store. What architectural considerations would you evaluate to ensure backward compatibility and minimal downtime?
  2. 2Different teams use adjacency lists for real‑time recommendation and batch analytics. How would you design a shared graph service that serves both low‑latency edge queries and high‑throughput traversals?
  3. 3If we need to evolve the graph schema (adding edge types, timestamps) while keeping existing adjacency list code functional, what strategy would you propose for versioning and migration?

Follow-up Questions

  • How would you modify the structure to support O(1) edge existence checks?
  • What changes are needed if the graph stores weighted edges?
  • Can you compare the memory trade‑offs of an adjacency list versus an adjacency matrix for a dense graph?
Share

Share via WhatsApp, X, Facebook, LinkedIn or copy link. Open Graph preview enabled.