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

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

Python3

# Function to find k-th
# missing element
def missingK(a, k, n) :
 
    difference = 0
    ans = 0
    count = k
    flag = 0
     
    # iterating over the array
    for i in range (0, n-1) :
        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
# Input array
a = [1, 5, 11, 19]
 
# k-th missing element
# to be found in the array
k = 11
n = len(a)
 
# calling function to
# find missing element
missing = missingK(a, k, n)
 
print(missing)
 
# This code is contributed by
# Manish Shaw (manishshaw1)

输出

14

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

方法二：

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

下面是上述方法的实现：

Python3

# Python3 program for above approach
 
# Function to find
# kth missing number
def missingK(arr, k):
  n = len(arr)
  l = 0
  u = n - 1
  mid = 0
  while(l <= u):
    mid = (l + u)//2;
    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 and (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;
    elif(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.
  less = arr[u] - (u + 1);
  k -= less;
   
  # Return arr[u] + k
  return arr[u] + k;
 
# Driver Code
if __name__=='__main__':
 
    arr = [2,3,4,7,11];
    k = 5;
   
    # Function Call
    print("Missing kth number = "+ str(missingK(arr, k)))
     
# This code is contributed by rutvik_56.

输出

Missing kth number = 9

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

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