排序数组中第 k 个缺失元素的 C++ 程序

给定一个递增序列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，否则迭代下一个元素。

C++

#include 
using namespace std;
 
// Function to find k-th
// missing element
int missingK(int a[], int k,
             int n)
{
    int difference = 0,
        ans = 0, count = k;
    bool flag = 0;
     
    // 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 = 1;
                    break;
                }
            else
                count -= difference;
        }
    }
     
    // if found
    if(flag)
        return ans;
    else
        return  -1;
}
 
// Driver code
int main()
{
    // Input array
    int a[] = {1, 5, 11, 19};
     
    // k-th missing element
    // to be found in the array
    int k = 11;
    int n = sizeof(a) / sizeof(a[0]);
     
    // calling function to
    // find missing element
    int missing = missingK(a, k, n);
     
    cout << missing << endl;
     
    return 0;
}

---

输出

14

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

方法二：

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

下面是上述方法的实现：

C++

// CPP program for above approach
#include 
#include 
using namespace std;
 
// Function to find
// kth missing number
int missingK(vector& arr, int k)
{
  int n = arr.size();
  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
int main()
{
    vector arr = {2,3,4,7,11};
    int k = 5;
   
    // Function Call
    cout <<"Missing kth number = "<<
                        missingK(arr, k)<

输出

8

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