Data Structures

- A. Stack follows LIFO (Last In, First Out) order, so it matches with IV.
- B. EOF (End Of File) is related to handling the end of file, which is an exception, so it matches with III.
- C. A Tree is a non-linear data structure, so it matches with II.
- D. A Queue follows FIFO (First In, First Out) order, so it matches with I.
Thus, the correct matching is A-IV, B-III, C-II, D-I.

When a queue is full and an attempt is made to insert a new element, the condition is called "Overflow". This typically occurs when the queue exceeds its maximum capacity.

In a queue, insertion (enqueue) takes place at the rear end (B), while deletion (dequeue) happens at the front end (A). This is the fundamental principle of queue data structure, following FIFO (First In, First Out) order.

The correct option is (C) :DataFrame.

In stack operations, the term "PUSH" is used to add an element to the stack. "POP" is used to remove the top element, while "PEEK" allows you to view the top element without removing it. "PULL" and "SEEK" are not stack-related terms.

The correct option is (D) :C and E only.

The correct option is (B) :n².

The time complexity of a binary search algorithm is O(log n), where "n" is the number of elements in the array. Binary search works by repeatedly dividing the search interval in half, which results in a logarithmic time complexity. It eliminates half of the remaining elements with each step, making it much more efficient than linear search (O(n)).
- O(n) (A) is the time complexity of a linear search, where every element is checked.
- O(n log n) (C) is typical for algorithms that involve both a linear pass through data and a logarithmic operation, such as merge sort.
- O(n²) (D) is the time complexity of algorithms like bubble sort, which involve nested iterations.
Thus, (B) O(log n) is the correct answer for binary search.

The Last-In-First-Out (LIFO) principle is used by stacks, where the last element added is the first one to be removed. A stack operates like a stack of plates, where you add and remove plates from the top.
- Queue (A) follows the First-In-First-Out (FIFO) principle, where the first element added is the first one removed.
- Linked List (C) is a linear data structure that does not inherently follow the LIFO or FIFO principle, as elements can be accessed in various ways.
- Array (D) is a data structure that holds elements in a fixed-size structure but does not inherently follow the LIFO or FIFO principle.
Thus, (B) Stack is the correct answer.

Dijkstra's algorithm is a widely used algorithm for finding the shortest path between nodes in a graph, particularly for graphs with non-negative edge weights. It works by selecting the node with the smallest tentative distance and exploring its neighbors, updating their distances iteratively.
- It detects cycles in a directed graph (B) refers to cycle detection algorithms, such as Depth First Search (DFS), not Dijkstra’s algorithm.
- It computes the minimum spanning tree (C) refers to algorithms like Kruskal’s or Prim’s algorithm, not Dijkstra’s.
- It performs topological sorting (D) is a task related to directed acyclic graphs (DAGs) and is typically solved using algorithms like Kahn’s algorithm, not Dijkstra’s.
Therefore, the correct answer is (A), as Dijkstra’s algorithm finds the shortest path in a weighted graph with non-negative weights.

Quick Sort has the best average-case time complexity of . It is an efficient divide-and-conquer algorithm that partitions the array into smaller sub-arrays and recursively sorts them. In the average case, it performs better than other sorting algorithms.
- Bubble Sort (A) has an average-case time complexity of , which makes it much slower than Quick Sort in most cases.
- Selection Sort (B) also has an average-case time complexity of .
- Insertion Sort (D) has an average-case time complexity of , but it can perform better than other algorithms on small or nearly sorted arrays.
Thus, the correct answer is (C), Quick Sort with .

In a binary tree, the maximum number of nodes at level is . Each level in a binary tree can have at most double the number of nodes as the previous level, starting with 1 node at level 0 (the root). For example, level 1 has 2 nodes, level 2 has 4 nodes, and so on.
- (A) is incorrect because the number of nodes does not grow quadratically with level number in a binary tree.
- (C) is also incorrect, as the number of nodes grows exponentially, not linearly with .
- (D) is incorrect because the factorial function does not describe the number of nodes at each level of a binary tree.
Thus, the correct answer is (B), .