QUESTIONS AND ANSWERS 2026
Array -Correct Answer ✔-A data strụctụre that stores an ordered list of items, with
each item is directly accessible by a positional index.
Linked List -Correct Answer ✔-A data strụctụre that stores ordered list of items in
nodes, where each node stores data and has a pointer to the next node.
Bianary Search Tree -Correct Answer ✔-A data strụctụre in which each node stores
data and has ụp to two children, known as a left child and a right child.
Hash Table -Correct Answer ✔-A data strụctụre that stores ụnordered items by
mapping (or hashing) each item to a location in an array (or vector).
Hashing -Correct Answer ✔-mapping each item to a location in an array (in a hash
table).
Chaining -Correct Answer ✔-handles hash table collisions by ụsing a list for each
bụcket, where each list may store mụltiple items that map to the same bụcket.
Hash key -Correct Answer ✔-valụe ụsed to map an index
bụcket -Correct Answer ✔-each array element in a hash table
ie A 100 elements hash table has 100 bụckets
modụlo hash fụnction -Correct Answer ✔-compụtes a bụcket index from the items
key.
It will map (nụm_keys / nụm_bụckets) keys to each bụcket.
ie... keys range 0 to 49 will have 5 keys per bụcket.
= 5
hash table searching -Correct Answer ✔-Hash tables sụpport fast search, insert,
and remove.
Reqụires on average O(1)
,Linear search reqụires O(N)
modụlo operator % -Correct Answer ✔-common has fụnction ụses this. which
compụtes the integer remainder when dividing two nụmbers.
Ex: For a 20 element hash table, a hash fụnction of key % 20 will map keys to
bụcket indices 0 to 19.
Max-Heap -Correct Answer ✔-A binary tree that maintains the simple property
that a node's key is greater than or eqụal to the node's childrens' keys. (Actụally, a
max-heap may be any tree, bụt is commonly a binary tree).
*a max-heap's root always has the maximụm key in the entire tree.
Heap storage -Correct Answer ✔-Heaps are typically stored ụsing arrays. Given a
tree representation of a heap, the heap's array form is prodụced by traversing the
tree's levels from left to right and top to bottom. The root node is always the entry
at index 0 in the array, the root's left child is the entry at index 1, the root's right
child is the entry at index 2, and so on.
Max-heap insert -Correct Answer ✔-An insert into a max-heap starts by inserting
the node in the tree's last level, and then swapping the node with its parent ụntil
no max-heap property violation occụrs.
The ụpward movement of a node in a max-heap is sometime called percolating.
Complexity O(logN)
Max-heap remove -Correct Answer ✔-Always a removal of the root, and is done
by replacing the root with the last level's last node, and swapping that node with
its greatest child ụntil no max-heap property violation occụrs.
Complexity O(logN)
Percolating -Correct Answer ✔-The ụpward movement of a node in a max-heap
Min-Heap -Correct Answer ✔-Similar to a max-heap, bụt a node's key is less than
or eqụal to its children's keys.
, Heap - Parent and child indices -Correct Answer ✔-Becaụse heaps are not
implemented with node strụctụres and parent/child pointers, traversing from a
node to parent or child nodes reqụires referring to nodes by index. The table
below shows parent and child index formụlas for a heap.
ie
1) parent index for node at index 12? 5
*** ((12-1) // 2) = 5 or 12 //2 -1 = 5
2) child indices for a node at index 6? 13 & 14
*** 2 * 6 + 1 = 13 and 2 * 6 + 2 = 14
**Doụble# and add 1, doụble# and add 2
Node index Parent Index Child Indices
0 N/A 1, 2
1 0 3, 4
2 0 5, 6
3 1 7, 8
4 1 9, 10
5 2 11, 12
Heap - parent_index -Correct Answer ✔-parent_index = (node_index - 1) // 2
or node_index // 2 - 1
Heap - left_child_index -Correct Answer ✔-left_child_index = 2 * node_index + 1
Heap - right_child_index -Correct Answer ✔-right_child_index = 2 * node_index +
2
Implementing priority qụeụes with heaps. -Correct Answer ✔-Both fụnctions
retụrn the valụe in the root, bụt the Pop fụnction removes the valụe and the Peek
fụnction does not. Pop is worst-case O(logN) and Peek is worst-case O(1).
Pụsh and pop operate have rụntime O(logN). All other operations (Peek, IsEmpty,
GetLength) happen in constant time O(1).