# Jump Search – Multiple Choice Questions and Answers (MCQs)

This set of Data Structures & Algorithms Multiple Choice Questions & Answers (MCQs) focuses on “Jump Search”.

1. What is the value of jump taken for maximum efficiency while implementing jump search?
A) n/2
B) n2
C) n1/2
D) log n

Explanation: In the worst-case scenario, the total number of comparisons needed will be n/k + k-1. For k=n1/2, this function will be the smallest. As a result, this jump value would be the most suitable for implementing jump search.

2. What is the auxiliary space requirement of the jump search?
A) O(n)
B) O(log n)
C) O(n1/2)
D) O(1)

Explanation: For searching the necessary element, jump search does not require any additional space. As a result, its auxiliary storage space allowance will be O(1).

3. Which of the following searching algorithm is fastest?
A) jump search
B) binary search
C) linear search
D) all are equally fast

Explanation: Among the available searching algorithms, binary search has the shortest time complexity (log n). In most instances, binary search is preferable.

4. In which of the following case jump search will be preferred over binary search?
A) jumping backwards takes significantly more time than jumping forward
B) jumping forward takes significantly more time than jumping backwards
C) when the given array is very large in size
D) when the given array is very small in size

Explanation: A binary can jump backwards up to log n times, while a jump search can only go backwards once. If jumping backwards is costly, jump search would be preferred over binary search.

5. Best case of jump search will have time complexity of _________
A) O(1)
B) O(n)
C) O(log n)
D) O(n log n)

Explanation: The best case for jump search is when the element being searched is the first element of the array. Only one comparison will be needed in this case. As a result, it will have an O time complexity (1).

6. Which of the following code correctly represent jump search?
A)

```int jumpSearch(int arr[], int x, int n)
{

int step = n*n;
int prev = 0;
while (arr[min(step, n)-1] < x)
{
prev = step;
step += sqrt(n);
if (prev >= n)
return -1;
}

while (arr[prev] < x)
{
prev++;

if (prev == min(step, n))
return -1;
}

if (arr[prev] == x)
return prev;

return -1;
}```

B)

```int jumpSearch(int arr[], int x, int n)
{

int step = sqrt(n);
int prev = 0;
while (arr[min(step, n)-1] < x)
{
prev = step;
step += sqrt(n);
if (prev >= n)
return -1;
}

while (arr[prev] < x)
{
prev++;

if (prev == min(step, n))
return -1;
}

if (arr[prev] == x)
return prev;

return -1;
}```

C)

```int jumpSearch(int arr[], int x, int n)
{

int step = sqrt(n);
int prev = 0;
while (arr[min(step, n)-1] < x)
{
prev = step;
step += sqrt(n);
if (prev == n)
return -1;
}

while (arr[prev] < x)
{
prev++;

if (prev == min(step, n))
return -1;
}

if (arr[prev] == x)
return prev;

return -1;
}```

D)

```int jumpSearch(int arr[], int x, int n)
{

int step = sqrt(n);
int prev = 0;
while (arr[min(step, n)-1] < x)
{
prev = step;
step += sqrt(n);
if (prev >= n)
return -1;
}

while (arr[prev] > x)
{
prev++;

if (prev == min(step, n))
return -1;
}

if (arr[prev] == x)
return prev;

return -1;
}```

Explanation: The correct code makes hops until it finds an element that is greater than the necessary element. After that, a backwards linear search is done. We return -1 if the element is not found.

7. Jump search is worse than linear search in terms of time complexity.
A) True
B) False

Explanation: The time complexity of linear search is O(n), while the time complexity of jump search is O(n1/2). In terms of time complexity, jump search is superior to linear search.

8. Jump search has a worst case time complexity of O(n).
A) True
B) False

Explanation:
In the worst and average cases, the time complexity of jump search is O(n1/2). The reason for this is that the optimum jump size is n1/2.

9. Jump search algorithm requires which of the following condition to be true?
A) array should be sorted
B) array should have not be sorted
C) array should have a less than 64 elements
D) array should be partially sorted

Explanation: The input array must be sorted for jump sort to work. If the array is not sorted, the algorithm will fail to produce the desired result.

10. Jumps are made in the jump search algorithm until ___________
A) element having value less than that of the required element is found
B) element having value equal to the median of values of the array is found
C) element having value greater than that of the required element is found
D) middle element is found equal to the element being searched

Explanation: Jumps are rendered in the jump search algorithm before an element with a value greater than the value of the element being checked is found. After that, a backwards linear search is carried out.

11. Which of the following step is taken after finding an element having value greater than the element being searched?
A) linear search takes place in the forward direction
B) linear search takes place in the backward direction
C) binary search takes place in the forward direction
D) binary search takes place in a backward direction

Explanation: First, an element with a higher value than the one being searched is discovered. Following that, a backward linear search is done.

12. How many jumps will be made in the worst case of jump search(let block jumped =k)?
A) n*k
B) n/k
C) k/n
D) n+k

Explanation:
When the value to be checked is in the last portion of the list, the worst case scenario occurs. As a result, the number of jumps will be n/k in this situation.

13. What will be the maximum number of comparisons that can be made in jump search algorithm (assuming k to be blocks jumped)?
A) k
B) n/k
C) k-1
D) k-1

Explanation:
The worst-case scenario happens when the element being searched appears right after the element that was compared during the previous hop. In this case, k-1 comparisons will be needed.

A jump search or block search is a search algorithm for ordered lists in computer science. A linear search on the sublist L[(k-1)m, km] is used to find the exact location of the search key in the list. The best value for m is n, where n represents the length of the list L. Since both steps of the algorithm look at a maximum of n products, it takes O(n) time to complete. This is preferable to a linear search but inferior to a binary search. A jump search has an advantage over a binary in that it only has to jump backwards once, while a binary will jump backwards up to log n times. If jumping backwards takes much longer than jumping forward, this can be critical.