Question

1) (5 pts) Consider the problem of finding the mode (most frequently occurring value) in an array. John attempts to solve the problem recursively. His strategy is to recursively call his mode function on the left half of the array and the right half of the array, and then use these answers to calculate the mode of the whole array. Assuming that his function only returns the mode and nothing else, why is his strategy doomed to fail?

Answer 1

This strategy is doomed to fail since it misses on the fact that there can be an element in both left half and right half such that its total frequency exceeds those of individual modes of left half and right half. Consider the array :

   left half    right half

The left half has mode 2(frequency 3), & the right half has mode 5(frequency 3), So his algorithm would consider 2 & 5 for overall mode, however it is to be noted that the element 3 has overall frequency 4, which should make it the mode despite having lower frequencies in left and right sub arrays. Morever since, the function only returns mode and not its frequency, we have no means of deciding whether the mode from left half has more frequency than the mode in right half or vice-versa.

The problem with this algo is as we continue to subdivide arrays, it will only give correct result if the mode occurs at consecutive places:

Recursion level 0	1 2 2 3 3 2    3 3 5 5 5 1
Recursion level 1	1 2 2 3 3 2	3 3 5 5 5 1
Recursion level 2	1 2 2	3    3    2	3    3    5	5    5    1
Recursion level 3	1	2 2	3	3 2	3	3 5	5	5 1
Recursion level 4	1	2	2	3	3	2	3	3	5	5	5	1

Thus we keep recurring as above table until finally we get subarray of size 1. But, now what? These individual subarrays of size 1 would have mode same as their only element. Combining them to get mode of subarray of size 1 or subarray of size 2 with same elements would work fine, but it won't work other wise. Consider these case of recorsion level 3:

CASE 1: We have subarray [1], since it is the only element, the mode would be 1.

CASE 2: We have subarray [2,2], which is divided as [2] & [2], each having mode 2 and this could be aggregated to get overall mode 2.

CASE 3: We have subarray [3,2], which is divided as [3] & [2], having mode 3 & 2 respectively. Now we have an ambiguity to chose whether 3 or 2 or both as the mode for the subarray of size 2. This is where the algorithm would fail.

Thus the ambiguity in aggregating the mode from left half & right half dooms this algorithm to fail.