A web browser lets you undo recently closed tabs in the reverse order they were closed. Which data structure is most appropriate for implementing this feature?

Queue — tabs are reopened in the order they were closed (FIFO) Stack — last closed tab is the first to be reopened (LIFO) Linked list — allows tabs to be reopened in any order Hash table — tabs are retrieved by their URL key

A hospital's emergency room triages patients by arrival time — the patient who arrived first is treated first when all priorities are equal. Which data structure models this correctly?

Stack — most recent arrival is treated first Binary tree — patients are sorted by condition severity Queue — first patient enqueued is the first dequeued (FIFO) Array — all patients are stored and accessed by index

A program frequently inserts and deletes records at arbitrary positions in the middle of a large dataset, but almost never accesses records by index. Which data structure minimises the cost of these operations?

Array — O(1) index access makes all operations fast Hash table — O(1) average lookup solves all performance problems Linked list — insertion and deletion require only pointer updates, O(1) once the position is found Stack — LIFO order makes insertions efficient

A compiler needs to check whether every opening bracket '(' in source code has a matching closing bracket ')'. Which data structure naturally solves this, and how?

Queue — process brackets in the order they appear Stack — push each '(', pop when ')' is found; unmatched brackets leave the stack non-empty at the end Array — count opening and closing brackets and compare totals Hash table — store bracket pairs as key-value entries

A dictionary application needs to look up word definitions in a dataset of 500,000 words in the shortest possible time. Which data structure gives the best average-case lookup performance?

Sorted array with binary search — O(log n) is sufficient Linked list — allows words to be inserted alphabetically Hash table — O(1) average lookup by computing the word's storage location directly Stack — LIFO access ensures recently looked-up words are found fastest

A file system on a computer organises directories within directories, each of which can contain files or more directories. Which data structure naturally represents this organisation?

Hash table — directory names hash to file locations Queue — directories are accessed in the order they were created Tree — hierarchical parent-child relationships mirror the directory structure Linked list — directories chain to one another sequentially

A social network needs to find the shortest chain of friend connections between two users (e.g., 'six degrees of separation'). Which data structure and algorithm combination is most appropriate?

Binary tree with in-order traversal — users are sorted alphabetically Array with linear search — checks all users one at a time Hash table with direct lookup — friend chains are stored as key-value pairs Graph with breadth-first search — finds shortest path in an unweighted graph

What is the difference between a float and an integer data type, and why does this distinction matter in engineering calculations?

Floats are always more precise than integers for all calculations Integers can store decimals; floats only store whole numbers Integers store whole numbers exactly; floats store decimal approximations — using integers for physical measurements causes rounding errors There is no meaningful difference; the compiler handles conversion automatically

A function in a program calls itself with a smaller input until it reaches a base case. This technique is called recursion. What data structure does the runtime use to track each function call, and what can go wrong if recursion is too deep?

A heap — excess calls are stored in dynamic memory instead A queue — function calls are processed in the order they were made The call stack — if recursion is too deep, the stack overflows, crashing the program A hash table — each recursive call is stored by its input value

An array provides O(1) access by index. A hash table provides O(1) average lookup by key. If you know the exact position (index) of every item you need, which should you prefer?

Hash table — it is always faster because it avoids index arithmetic Linked list — sequential access is more cache-efficient Array — direct index access is simpler and has lower overhead than hashing Tree — logarithmic access is better than constant-time access

A hash table's performance degrades significantly when many keys hash to the same slot (a collision). What is this degradation called, and what is the worst-case time complexity when it occurs?

Overflow — the table runs out of memory and crashes Fragmentation — memory becomes non-contiguous, slowing access Collision — worst case degrades to O(n) if all keys map to the same slot Deadlock — multiple lookups block each other

A program stores a boolean variable called 'isSensorFaulted'. A boolean can only hold two values. Why is using a boolean preferable to using an integer (0 or 1) for this purpose?

Booleans are faster to process than integers in all programming languages Booleans use less memory, which matters on all modern systems Booleans communicate intent clearly and prevent invalid values — an integer could mistakenly be set to 5 Integers cannot represent false; only booleans can