Google Software Engineer Interview Questions

A process is an isolated operating system execution unit containing its own dedicated virtual memory space, page tables, file descriptors, and security contexts. Context switching between processes is resource-intensive due to CPU Translation Lookaside Buffer (TLB) invalidations. A thread is a lightweight execution path spawned inside a parent process. Multiple threads share the process's text, heap memory, and global variables, but maintain independent stacks and register sets. Thread context switching is significantly faster, but requires strict concurrency guardrails to prevent data race conditions.

Implement an LRU cache by combining an O(1) lookup hash map (std::unordered_map) with an O(1) mutation doubly linked list. The hash map maps incoming keys directly to corresponding iterator nodes inside the linked list. Upon a cache hit, move the accessed node to the head of the linked list to mark it as most recently used. Upon a cache miss, insert a new node at the list head; if capacity is exceeded, evict the entry mapped to the tail node. For multi-threaded production scales, wrap operations in a mutex lock or shard data across distinct bucket segments to minimize concurrent lock contention.

Initialize a min-heap (Priority Queue) and populate it with the head nodes of all k sorted linked lists, requiring O(k) initialization space. In an iterative loop, extract the minimum root element from the heap and append it to your output list. If that extracted node possesses a valid next pointer element, push its successor node back into the min-heap. This algorithm achieves an optimal time complexity of O(N log k), where N represents the total aggregate count of nodes across all k lists, while maintaining an auxiliary space boundary of O(k) to preserve heap invariants.

Apply Floyd’s Cycle-Finding Algorithm, commonly called the Tortoise and Hare algorithm, utilizing two concurrent pointers initialized at the head node. Advance the slow pointer forward by exactly one node increment per cycle, while moving the fast pointer forward by two increments. If the linked list contains a cycle, the fast pointer will mathematically wrap around and intersect the slow pointer from behind inside the loop segment. This methodology achieves a time performance profile of O(n) and executes entirely in O(1) auxiliary space, bypassing hash set memory allocation overhead entirely.

Execute a level-order Breadth-First Search (BFS) algorithm starting directly from the source vertex. Utilize a FIFO queue to manage unvisited nodes and maintain an external boolean lookup set to track visited vertices to prevent cyclic loops. Because BFS processes nodes iteratively outward in uniform concentric rings, the first instance where the target vertex is discovered is mathematically guaranteed to be the absolute shortest path in terms of edge count. The total algorithmic execution complexity scales linearly to O(V + E) time and O(V) space memory capacity.