InterviewStack.io LogoInterviewStack.io

Trees and Graphs Questions

Comprehensive knowledge of tree and graph data structures and algorithms commonly tested in coding interviews. Candidates should understand representations such as adjacency list and adjacency matrix and when to use each, and tree representations including n ary trees and binary search trees. Expect to implement and reason about traversals including depth first search and breadth first search, tree traversals such as pre order in order and post order, and level order traversal. Cover algorithms including topological sorting for directed acyclic graphs, cycle detection, connected components, shortest path algorithms such as breadth first search for unweighted graphs, Dijkstra for nonnegative weights, and Bellman Ford for graphs with negative edges, and minimum spanning tree algorithms such as Kruskal and Prim. Include disjoint set union find for connectivity and for use with Kruskal, lowest common ancestor techniques and implementations, tree dynamic programming problems, serialization and deserialization, reconstruction from traversals, balancing and validation checks for binary search trees and balanced tree concepts, diameter and path sum problems, and common interview patterns such as path finding dependency resolution and structural transformation. Emphasize implementation details and common pitfalls including correct use of visited tracking recursion depth edge cases and disconnected components, and practice articulating time and space complexity tradeoffs and algorithm selection under different constraints.

HardTechnical
0 practiced
For large graphs with high average degree in local neighborhoods, discuss algorithmic choices to compute single-source shortest paths efficiently. Implement an optimized Dijkstra variant in Python using a binary heap and explain why you may choose to push duplicate heap entries instead of implementing decrease-key. Discuss when adjacency matrix or specialized heap structures are preferable.
HardTechnical
0 practiced
Explain message-passing GNN layers and derive computational and memory complexity per layer for full-neighborhood aggregation. Provide a Python-like pseudo-code sketch of an optimized sparse aggregation using CSR format (iterating row pointers and scatter-add) and discuss numerical stability, batching, and memory tradeoffs.
MediumTechnical
0 practiced
Given an undirected weighted tree with n nodes and edge list (u, v, w), implement compute_tree_diameter(n, edges) in Python using two BFS/DFS passes (or appropriate weighted variant) and return both the diameter length and the sequence of nodes on that diameter path. Explain why two passes suffice on trees.
EasyTechnical
0 practiced
Write count_connected_components(n, edges) in Python to return the number of connected components in an undirected graph with nodes 0..n-1. Explain complexity and which graph representation is preferable when the graph is sparse versus dense.
MediumTechnical
0 practiced
Implement an efficient union-find (disjoint set) structure in Python supporting union(a, b) and connected(a, b) queries. Use union by size/rank and path compression. Additionally, describe how you'd support rollback operations to enable offline dynamic connectivity queries (e.g., divide-and-conquer on time).

Unlock Full Question Bank

Get access to hundreds of Trees and Graphs interview questions and detailed answers.

Sign in to Continue

Join thousands of developers preparing for their dream job.