用于排序数组中第 k 个缺失元素的Java程序

给定一个递增序列a[] ，我们需要在递增序列中找到第 K 个缺失的连续元素，该元素不存在于序列中。如果没有第 k 个缺失元素，则输出 -1。

例子 ：

Input : a[] = {2, 3, 5, 9, 10};   
        k = 1;
Output : 1
Explanation: Missing Element in the increasing 
sequence are {1,4, 6, 7, 8}. So k-th missing element
is 1

Input : a[] = {2, 3, 5, 9, 10, 11, 12};       
        k = 4;
Output : 7
Explanation: missing element in the increasing 
sequence are {1, 4, 6, 7, 8}  so k-th missing 
element is 7

方法一：开始迭代数组元素，对每个元素检查下一个元素是否连续，如果不连续，则取这两者的差，检查差是否大于或等于给定的k，然后计算 ans = a[i] + count，否则迭代下一个元素。

Java

// 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)

输出

14

时间复杂度： O(n)，其中 n 是数组中元素的数量。

方法二：

应用二分搜索。由于数组已排序，我们可以在任何给定的索引处找到缺少多少数字，如 arr[index] – (index+1)。我们将利用这些知识并应用二进制搜索来缩小搜索范围，以找到更容易从中获取丢失数字的索引。

下面是上述方法的实现：

Java

// 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.

输出

Missing kth number = 9

时间复杂度： O(logn)，其中 n 是数组中元素的数量。

有关详细信息，请参阅有关排序数组中第 k 个缺失元素的完整文章！