Java Program for k-th missing element in sorted array

// Java program to check for
// even or odd
import java.io.*;
import java.util.*;
 
public class GFG {
     
    // Function to find k-th 
    // missing element
    static int missingK(int []a, int k, 
                                 int n)
    {
        int difference = 0, 
            ans = 0, count = k;
        boolean flag = false;
         
        // iterating over the array
        for(int i = 0 ; i < n - 1; i++)
        { 
            difference = 0;
             
            // check if i-th and 
            // (i + 1)-th element 
            // are not consecutive
            if ((a[i] + 1) != a[i + 1]) 
            {
                 
                // save their difference
                difference += 
                    (a[i + 1] - a[i]) - 1;
                 
                // check for difference
                // and given k
                if (difference >= count)
                    {
                        ans = a[i] + count;
                        flag = true;
                        break;
                    }
                else
                    count -= difference;
            }
        }
         
        // if found
        if(flag)
            return ans;
        else
            return -1;
    }
     
    // Driver code
    public static void main(String args[])
    {
         
        // Input array
        int []a = {1, 5, 11, 19};
         
        // k-th missing element 
        // to be found in the array
        int k = 11;
        int n = a.length;
         
        // calling function to
        // find missing element
        int missing = missingK(a, k, n);
         
        System.out.print(missing);
    }
 
}
 
// This code is contributed by
// Manish Shaw (manishshaw1)

// Java program for above approach
public class GFG
{

  // Function to find 
  // kth missing number
  static int missingK(int[] arr, int k) 
  {
    int n = arr.length;
    int l = 0, u = n - 1, mid;    
    while(l <= u) 
    {
      mid = (l + u)/2;        
      int numbers_less_than_mid = arr[mid] - 
        (mid + 1);

      // If the total missing number 
      // count is equal to k we can iterate
      // backwards for the first missing number
      // and that will be the answer.
      if(numbers_less_than_mid == k) 
      {

        // To further optimize we check 
        // if the previous element's
        // missing number count is equal 
        // to k. Eg: arr = [4,5,6,7,8]
        // If you observe in the example array, 
        // the total count of missing numbers for all
        // the indices are same, and we are
        // aiming to narrow down the 
        // search window and achieve O(logn)
        // time complexity which 
        // otherwise would've been O(n).
        if(mid > 0 && (arr[mid - 1] - (mid)) == k) 
        {
          u = mid - 1;
          continue;
        }

        // Else we return arr[mid] - 1.
        return arr[mid] - 1;
      }

      // Here we appropriately 
      // narrow down the search window.
      if(numbers_less_than_mid < k) 
      {
        l = mid + 1;
      } 
      else if(k < numbers_less_than_mid) 
      {
        u = mid - 1;
      }
    }

    // In case the upper limit is -ve 
    // it means the missing number set
    // is 1,2,..,k and hence we directly return k.
    if(u < 0)
      return k;

    // Else we find the residual count 
    // of numbers which we'd then add to
    // arr[u] and get the missing kth number.
    int less = arr[u] - (u + 1);
    k -= less;

    // Return arr[u] + k
    return arr[u] + k;
  }

  // Driver code
  public static void main(String[] args) 
  {
    int[] arr = {2,3,4,7,11};
    int k = 5;

    // Function Call
    System.out.println("Missing kth number = "+ missingK(arr, k));
  }
}

// This code is contributed by divyesh072019.