Data Structures: 21 MCQs with answers

A method of organizing and storing data for efficient use

A data structure is a method of organizing and storing data so it can be used efficiently for processing, retrieval, updating, and deletion.

char

Primitive data structures are atomic single-value types provided by the language: int, char, float, bool, pointer. Array, Stack, and Linked List are non-primitive collections.

Non-primitive, because it organizes multiple items

The primitive/non-primitive line is about whether the type is atomic or a collection — not about what it contains. An array organizes multiple items, so it is non-primitive.

One predecessor and one successor

Linear structures arrange elements sequentially: each element has a unique predecessor and successor, except the first and last.

Graph

Graph is non-linear — one element can connect to many others, forming networks. Queue, Array, and Linked List are linear.

Compile time, with fixed size

Static data structures allocate memory at compile time and have a fixed size, e.g., int arr[100]. Dynamic structures allocate at runtime.

Stack

Stack follows LIFO (Last In, First Out). Queue follows FIFO (First In, First Out).

Stack

Undo reverses the most recent action first — that is LIFO behavior, which is a Stack.

True

An array stores elements in contiguous memory, so its i-th element address is base + (i × element size), enabling O(1) random access.

What operations exist and how they behave

An ADT is a logical description of what operations a data type supports and how they behave, without specifying how they are implemented.

Either an array or a linked list

The Stack ADT defines the operations (push, pop, peek, isEmpty) but not the implementation. It can be built on either an array or a linked list.

1008

Address = base + (i × element size) = 1000 + (2 × 4) = 1008. This is why array access is $O(1)$.

Linked list, because only pointers change

With an array, every existing element must shift — $O(n)$. With a linked list, you create one node and update two pointers — $O(1)$.

Array, because of direct address calculation

Array access is $O(1)$ via the address formula. A linked list requires walking 500 nodes — $O(n)$.

Google Maps navigation

Google Maps uses a Graph — locations as nodes, roads as edges. Undo uses Stack, railway line uses Queue, folders use Tree.

Linked list

Dynamic data structures allocate memory at runtime using pointers and malloc()/calloc(). Linked lists, trees, and graphs are dynamic.

Linked List

A linked list allows O(1) insertion at the end if you maintain a pointer to the last node, while an array requires O(n) time to resize or shift elements.

O(log n)

In a balanced BST, finding the k-th smallest element can be done in O(log n) time by traversing down the tree, maintaining a count of nodes visited.

Deque

A Deque (double-ended queue) allows O(1) operations for adding and removing elements from both ends, unlike an array or linked list which may incur O(n) in some cases.

Static structures are faster in access due to contiguous memory.

Static structures are faster in access because they use contiguous memory, while dynamic structures may have overhead due to pointer management.

Linked List

A linked list requires careful memory management because each node is allocated dynamically, and forgetting to free memory can lead to leaks, unlike static structures.