Data Structures & Algorithms MCQ

Explanation

Array elements are stored contiguously in memory and accessed directly via base address + index × element size, making it O(1) regardless of array size.

Explanation

A stack processes the most recently added element first. Operations are push (insert) and pop (remove), both from the same end (top).

Explanation

Inserting at the head only requires creating a new node and updating one pointer, which takes constant time regardless of list length.

Explanation

A queue removes elements in the order they were added. Elements are enqueued at the rear and dequeued from the front.

Explanation

In a BST, all values in a node's left subtree are less than the node's value, and all values in the right subtree are greater. This ordering enables O(log n) average search.

Explanation

Binary search halves the search space each step, yielding O(log n) comparisons in the worst case. It requires the array to be sorted.

Explanation

A hash function converts a key into an index in an underlying array. With a good hash function, average-case get/put/delete are O(1).

Explanation

A graph G = (V, E) consists of vertices V and edges E that connect pairs of vertices. Graphs can be directed or undirected, weighted or unweighted.

Explanation

Preorder traversal visits the current node first, then recursively visits left and right subtrees. Useful for copying or serializing a tree.

Explanation

Each recursive call adds a stack frame, so n recursive calls consume O(n) stack space.

Explanation

A min-heap ensures the minimum element is always at the root. insert and extract-min take O(log n) by bubbling up or down.

Explanation

Bubble sort compares adjacent elements and swaps them if out of order, requiring up to n*(n-1)/2 comparisons in the worst case.

Explanation

Depth-First Search explores as far as possible along a branch before backtracking. It uses a stack (or recursion) and is useful for cycle detection and topological sort.

Explanation

Each node in a doubly linked list stores a value and two pointers: next and prev. This allows O(1) deletion given a node reference, and bidirectional traversal.

Explanation

Merge sort achieves O(n log n) in all cases (best, average, worst). Quicksort also averages O(n log n) but has O(n²) worst case.

Explanation

An adjacency matrix uses O(V²) space. Checking if an edge exists is O(1), but iterating all edges is O(V²). Better for dense graphs.

Explanation

A balanced binary tree has O(log n) height since each level roughly doubles the node count. This ensures O(log n) operations.

Explanation

A binary heap allows insert in O(log n) and extract-min/max in O(log n), making it ideal for priority queues.

Explanation

Inorder traversal (left, root, right) on a BST visits nodes in ascending value order, which is why it's used to check if a tree is a valid BST.

Explanation

With a good hash function and low load factor, the average case for search, insert, and delete in a hash table is O(1). Collisions can degrade this to O(n).

Explanation

A circular queue reuses empty positions at the start of the array by treating the array as circular, avoiding wasted space in linear queue implementations.

Explanation

A tree is a special case of a graph: it is connected, has no cycles, and has exactly n-1 edges for n vertices.

Explanation

Push adds an element to the top of the stack. Pop removes from the top. Peek views the top without removing.

Explanation

Quicksort degrades to O(n²) when the pivot is always the smallest or largest element (e.g., sorted input with naive pivot selection). Randomized pivot reduces this risk.

Explanation

A deque (pronounced "deck") supports push and pop from both front and back, generalizing both stacks and queues.

Explanation

A spanning tree of a connected graph contains all V vertices and exactly V-1 edges, forming a tree (no cycles). A minimum spanning tree minimizes total edge weight.

Explanation

Merge sort divides the array into halves (log n levels) and merges them (O(n) per level), giving O(n log n) in all cases.

Explanation

A trie stores strings by sharing common prefixes. Lookup, insert, and delete take O(L) where L is the string length, regardless of how many strings are stored.

Explanation

BFS uses a queue to explore all neighbors before going deeper, guaranteeing shortest paths (fewest edges) in unweighted graphs.

Explanation

Self-balancing BSTs (AVL, Red-Black, etc.) perform rotations after insertions/deletions to keep height O(log n), avoiding O(n) worst-case degradation.

Explanation

Big O notation describes the worst-case upper bound on time (or space) complexity, ignoring constant factors and lower-order terms.

Explanation

Collisions are inevitable (pigeonhole principle). They are resolved using chaining (linked lists at each bucket) or open addressing (probing for an empty slot).

Explanation

Insertion sort has O(n) best case on nearly sorted data (few swaps needed) and O(n²) worst case. It's efficient for small n and is used as a subroutine in Timsort.

Explanation

In-degree counts edges pointing into a node. Out-degree counts edges going out. Both matter in algorithms like topological sort.

Explanation

Every function call pushes a frame onto the call stack. Infinite or excessively deep recursion exhausts the fixed-size stack, causing a stack overflow.

Explanation

Linked lists allow O(1) insertion/deletion when you have a pointer to the node, without shifting elements. However, random access is O(n).

Explanation

Postorder (left, right, root) visits children before parent. Used for deleting trees and evaluating expression trees (process operands before operator).

Explanation

Amortized analysis averages cost over a sequence. Dynamic array append is O(1) amortized: most appends are O(1), and occasional O(n) doubling averages out.

Explanation

Full binary tree: every node has 0 or 2 children. Complete binary tree: all levels are full except possibly the last, which is filled from left to right. Heaps use complete binary trees.

Explanation

Sentinel (dummy) nodes eliminate special cases for empty lists or boundary conditions, simplifying code at the cost of one extra node.

Explanation

With a binary heap priority queue, each edge relaxation takes O(log V) for the heap update. Total: O((E + V) log V), simplified to O(E log V) for connected graphs.

Explanation

AVL trees track the balance factor (height difference of left and right subtrees) and perform single or double rotations to keep it within {-1, 0, 1}, guaranteeing O(log n) operations.

Explanation

DP applies to problems with optimal substructure and overlapping subproblems. Results are memoized (top-down) or tabulated (bottom-up) to achieve polynomial complexity instead of exponential.

Explanation

Topological sort applies only to DAGs (directed acyclic graphs). It's used for scheduling tasks, build dependency resolution, and course prerequisites.

Explanation

Floyd-Warshall computes all-pairs shortest paths using dynamic programming in O(V³) time and O(V²) space. It handles negative edge weights but not negative cycles.

Explanation

Both find Minimum Spanning Trees. Prim's is vertex-based and faster for dense graphs. Kruskal's is edge-based and faster for sparse graphs using Union-Find.

Explanation

Red-Black trees maintain five invariants (root is black, red nodes have black children, equal black height on all paths) guaranteeing height ≤ 2 log(n+1).

Explanation

Bellman-Ford relaxes all edges V-1 times in O(VE) time. It works with negative weights and detects negative cycles (if relaxation occurs on the V-th pass).

Explanation

Union-Find supports union and find operations. With path compression and union by rank, both operations run in near-O(1) (O(α(n)) amortized). Used in Kruskal's and cycle detection.

Explanation

KMP preprocesses the pattern to build a failure function, avoiding redundant character comparisons, achieving O(n + m) where n is text length and m is pattern length.

Explanation

Memoization (top-down DP) stores computed results in a table. Recursive Fibonacci with memoization drops from O(2^n) to O(n) by avoiding recomputation.

Explanation

B+ trees keep all keys in leaves with leaf-level linked list, optimizing range queries. B-trees store data in all nodes. Both maintain O(log n) operations. B+ trees are used in databases.

Explanation

A segment tree is a binary tree built over an array enabling O(log n) range queries and point updates. Each node stores aggregate info for a subarray.

Explanation

Build-heap runs in O(n) despite n sift-down operations because lower nodes have smaller subtrees. The total work sums to O(n) by geometric series analysis.

Explanation

LRU cache evicts the least recently used item. A hash map gives O(1) lookup by key, and a doubly linked list maintains recency order with O(1) move-to-front on access.

Explanation

Kadane's algorithm uses DP to track the maximum subarray sum ending at each position, updating the global max at each step in a single O(n) pass.

Explanation

A skip list maintains multiple levels of linked lists. Upper levels act as express lanes. Average search is O(log n) with high probability through randomized level assignment.

Explanation

Two pointers (left/right or slow/fast) solve problems like pair sum, removing duplicates, and finding the longest window in O(n) instead of O(n²) brute force.

Explanation

A Fenwick tree uses the lowest set bit of an index to determine responsibility ranges, enabling O(log n) prefix sums and updates with minimal code and memory.

Explanation

Sliding window maintains a contiguous subarray and adjusts it with two pointers. Used for maximum sum subarray of size k, longest substring without repeating characters, etc.

Explanation

In directed graph DFS, a back edge (edge to a node currently on the recursion stack, i.e., gray/in-progress) indicates a cycle. Three-color DFS is the classic approach.

Explanation

The master theorem gives closed-form solutions for T(n) = aT(n/b) + f(n) based on comparing f(n) with n^(log_b a). Used for merge sort, binary search, and Strassen's algorithm.

Explanation

LCS finds the longest subsequence (characters in order but not necessarily contiguous) common to two strings. DP solves it in O(m*n) time and space.

Explanation

0/1 knapsack is an NP-hard optimization problem solved by DP in O(n*W) pseudo-polynomial time. Each item is either taken (1) or not (0).

Explanation

Heap sort builds a max-heap in O(n), then extracts the maximum n times (each extraction is O(log n)), giving O(n log n) overall. It sorts in-place.

Explanation

An SCC is a maximal set of vertices such that there exists a path between any two vertices in both directions. Kosaraju's and Tarjan's algorithms find SCCs in O(V + E).

Explanation

Greedy works when the greedy choice property holds (local optimum leads to global). DP is needed when subproblem solutions overlap and greedy fails (e.g., 0/1 knapsack).

Explanation

Radix sort beats O(n log n) comparison sorts when the digit count d is small. For 32-bit integers (d=4 with 8-bit digits, k=256), it runs in O(n).

Explanation

A* uses f(n) = g(n) + h(n) where g is cost from start and h is an admissible heuristic estimate to goal. It finds optimal paths faster than Dijkstra in practice.

Explanation

A monotonic stack processes each element once (O(n) total). It efficiently finds the next greater element, largest rectangle in histogram, and trapping rain water.

Explanation

By storing each visited number's index in a hash map, you can check in O(1) average time whether the complement (target minus current value) has already been seen, reducing the brute-force O(n²) approach to a single O(n) pass.

Explanation

For a 0-indexed binary heap stored in an array, the parent of node i is at index floor((i - 1) / 2), while its children are at 2i + 1 and 2i + 2. This compact mapping avoids storing explicit pointers.

Explanation

Floyd's algorithm advances a slow pointer by one node and a fast pointer by two nodes per step. If a cycle exists, the fast pointer laps the slow pointer and they meet inside the loop, detecting the cycle in O(n) time and O(1) space.

Explanation

Array-backed stacks store elements contiguously, improving cache performance and reducing per-element overhead, but may need costly resizing. Linked-list-backed stacks grow one node at a time with O(1) push/pop but pay extra memory for pointers and have worse cache behavior.

Explanation

Counting sort builds a frequency array indexed by key value, computes prefix sums to determine final positions, and places elements accordingly, achieving O(n + k) time. It becomes inefficient in time and space when the key range k is very large relative to n.

Explanation

Inserting into a hash set and checking membership both take O(1) average time, so scanning the collection once and tracking seen elements detects duplicates in O(n) average time, which is faster than the O(n log n) cost of sorting the data first.

Explanation

BFS processes nodes level by level using a queue, so the first time it reaches the target it has found a shortest path (in terms of edge count) in an unweighted graph. DFS uses a stack (or recursion) and explores one path fully before backtracking, which can reach the target via a longer route first.

Explanation

Naive pivot choices like always picking the first or last element cause O(n²) behavior on sorted or reverse-sorted input. Randomized or median-of-three pivot selection makes worst-case behavior far less likely in practice, keeping expected performance close to O(n log n), though it does not change the theoretical worst case.

Explanation

Recursive calls implicitly use the call stack to remember pending work and return points. Replacing recursion with an explicit stack means the programmer pushes and pops that same state manually, which can avoid stack-overflow risk for deep recursion and sometimes improves performance.

Explanation

Binary search relies on jumping directly to the middle index in O(1), which arrays support via index arithmetic. A singly linked list requires walking node by node to reach the middle, making each "jump" O(n) and reducing the overall approach to no better than linear search.

Explanation

Array doubling: each element is copied at most O(log n) times total. Over n pushes: total work is n + n/2 + n/4 + ... < 2n, so O(1) amortized per push.

Explanation

Tarjan's runs a single DFS pass with a stack, assigning discovery times and low-link values, finding all SCCs in O(V + E) time.

Explanation

O notation is an upper bound (worst case). Ω notation is a lower bound (best case). Θ notation is a tight bound (both upper and lower). Proving Ω lower bounds requires adversarial arguments.

Explanation

Aho-Corasick builds a trie with KMP-style failure links. It matches all k patterns in text of length n with total pattern length m in O(n + m + z), where z is match count.

Explanation

Van Emde Boas tree achieves O(log log U) operations by recursively splitting the universe into sqrt(U) clusters, dramatically faster than O(log n) for integer keys with bounded universe U.

Explanation

P is the class of problems solvable in polynomial time. NP is the class verifiable in polynomial time. The open question is whether P = NP. Most believe P ≠ NP.

Explanation

A suffix array combined with an LCP (Longest Common Prefix) array enables efficient string operations: pattern search in O(m log n), LRS in O(n), and is often preferable to suffix trees in practice.

Explanation

Cache-oblivious algorithms (Frigo et al.) use recursive divide-and-conquer that automatically adapts to any cache size. Examples: cache-oblivious sorting, matrix multiplication, and merge sort.

Explanation

A decision tree for n-element sorting has n! leaves. Its height is ≥ log₂(n!) = Θ(n log n) by Stirling's approximation, proving no comparison sort beats Ω(n log n).

Explanation

A treap is a randomized BST: each node has a key (BST order) and a random priority (max-heap order). The random priorities keep height O(log n) with high probability.

Explanation

Link-cut trees (Sleator-Tarjan) use auxiliary splay trees to represent paths. They support link, cut, find-root, and path-aggregate operations in O(log n) amortized.

Explanation

HLD decomposes a tree into chains by always following the child with the largest subtree. Any root-to-leaf path crosses O(log n) chains, enabling efficient path queries with a segment tree.

Explanation

Persistent data structures keep all versions by path copying (only modified nodes are duplicated). Persistent segment trees enable version queries in O(log n) per operation.

Explanation

Bloom filters use k hash functions and a bit array. Membership check is O(k). False positives are possible; false negatives are not. Used in databases (Cassandra), browsers (malware detection).

Explanation

NP-hard: at least as hard as hardest NP problems (may not be in NP). NP-complete: NP-hard AND in NP. Halting problem is NP-hard but not NP-complete (undecidable).

Explanation

Fibonacci heaps support O(1) amortized insert and decrease-key, O(log n) amortized delete-min. This makes Dijkstra O(E + V log V) with Fibonacci heap vs O(E log V) with binary heap.

Explanation

The Z-array Z[i] gives the length of the longest common prefix between the string and its suffix starting at i. Concatenating pattern + "$" + text and computing Z[i] finds pattern occurrences in O(n + m).

Explanation

Fractional cascading augments each list with elements from the next, enabling cascaded search: the first list is searched in O(log n), then O(1) per additional list using embedded pointers.

Explanation

The decision-tree lower bound applies only to comparison-based sorting. Radix sort, counting sort, and bucket sort are non-comparison algorithms exploiting integer key structure, achieving linear time.

Explanation

QuickSelect finds the k-th smallest element in O(n) expected time by partitioning like quicksort but recursing only on the relevant partition. Worst case O(n²) for adversarial pivots; Median-of-Medians gives O(n) worst case.