Recursion

To make the code run faster.

To call the method again with a modified input.

To prevent the method from running indefinitely by providing a stopping condition.

To handle errors that may occur during the recursive calls.

A method calling another method in the same class.

A method calling itself with a modified version of the original problem.

A method that does not have a return statement.

A method that only contains a base case.

0

3

6

10

Recursive code is always more efficient.

Recursive code can lead to stack overflow errors if the base case is not reached or defined incorrectly.

Recursive code is easier to read and understand.

Recursive code always uses less memory.

When the array is empty.

When the index is 0.

When the index is equal to the length of the array.

When the array contains only one element.

Recursion is generally faster.

Recursion requires less memory.

Recursion can lead to stack overflow errors for large arrays.

Recursion is simpler to implement.

The array must be sorted.

The array must contain only positive numbers.

The array must not contain duplicate values.

The array must be of even length.

Search the subarray {6, 8, 10}.

Search the subarray {2, 4}.

Search the subarray {2}.

Search the subarray {2, 4, 6}.

$O(n)$

$O(log n)$

$O(1)$

$O(n^2)$

To divide the array into smaller sub-arrays.

To sort each half of the array independently.

To combine two sorted sub-arrays into a single sorted array.

To find the middle element of the array.