Question

An array A of n integers is called semi-sorted if it is increasing until some index and then decreasing afterwards. In other words, there is some index 1 ≤ p ≤ n such that: • A[i] < A[i + 1] for 1 ≤ i < p, and • A[i] > A[i + 1] for p ≤ i < n. Note that in this case, A[p] is the maximum element of A. Give an algorithm with running time O(logn) that finds the maximum element of A, assuming that A is semi-sorted. Prove the correctness of your algorithm as well as do the analysis of the running time.
Hint: We can use a modified binary search. The idea is if we pick an index i and compare A[i] with A[i+1] we can determine if i is before the “peak” (i.e. if i ≤ p) or if i is after the peak: if A[i] < A[i+1] then we can conclude that the maximum appears in A[(i + 1),...,n] and if A[i] > A[i + 1] then the maximum is in A[1,...,i]. For correctness, if your algorithm uses a loop, formulate a loop invariant (LI) - what remains to be true throughout all iterations of your loop so that when the loop terminates, LI implies that the maximum element of A is found? If your algorithm is defined by recursion, use Induction to prove the correctness.

Answer 1

Java Program to find the peak element

public class Solution {

    public static void main(String[] args) {
        //array in which element to be found
        int[] A = {4, 5, 6, 7, 0, 1, 2};
        // to find the position of minimum index
        int pos = findMin(A);
        if (pos > 0) {
            System.out.println(A[pos - 1]);
        } else {
            System.out.println(A[A.length - 1]);
        }
    }

    //using binary search to find the peak element
    private static int findMin(int[] A) {
        int n = A.length;
        int low = 0, high = n - 1;
        int mid = 0;
        //using while loop
        while (low <= high) {
            mid = low + (high - low) / 2;
            //checking if the element is smallest or not
            if (mid + 1 < n && mid - 1 >= 0 && A[mid] < A[mid - 1] && A[mid] < A[mid + 1]) {
                break;
            } else if (mid < n && mid >= 0 && A[mid] > A[high]) {
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }
        //returning the position of smallest element
        return mid;
    }

}

Output

7