在算术级数中找到缺少的数字

给定一个数组，该数组按顺序表示算术级数的元素。进度中缺少一个元素，请找到缺失的数字。

例子：

Input: arr[]  = {2, 4, 8, 10, 12, 14}
Output: 6

Input: arr[]  = {1, 6, 11, 16, 21, 31};
Output: 26

一个简单的解决方案是线性遍历数组并找到丢失的数字。该解决方案的时间复杂度为O(n)。

我们可以使用Binary Search在O(Logn)时间内解决此问题。这个想法是去中间的元素。检查中点和下一个中间点之间的差是否等于diff，如果不相等，则缺少的元素位于中点和中点+1之间。如果中间元素等于算术级数中的^第n / 2^个项(让n为输入数组中元素的数量)，则缺少的元素位于右半部分。其他元素位于左半部分。

以下是上述想法的实现。

C++

// C++ program to find the missing number 
// in a given arithmetic progression
#include
using namespace std;
#define INT_MAX 2147483647;
class GFG
{
      
// A binary search based recursive function that returns
// the missing element in arithmetic progression
public:int findMissingUtil(int arr[], int low, 
                           int high, int diff)
{
    // There must be two elements to find the missing
    if (high <= low)
        return INT_MAX;
  
    // Find index of middle element
    int mid = low + (high - low) / 2;
  
    // The element just after the middle element is missing.
    // The arr[mid+1] must exist, because we return when
    // (low == high) and take floor of (high-low)/2
    if (arr[mid + 1] - arr[mid] != diff)
        return (arr[mid] + diff);
  
    // The element just before mid is missing
    if (mid > 0 && arr[mid] - arr[mid - 1] != diff)
        return (arr[mid - 1] + diff);
  
    // If the elements till mid follow AP, then recur
    // for right half
    if (arr[mid] == arr[0] + mid * diff)
        return findMissingUtil(arr, mid + 1, 
                               high, diff);
  
    // Else recur for left half
    return findMissingUtil(arr, low, mid - 1, diff);
}
  
// The function uses findMissingUtil() to 
// find the missing element in AP. 
// It assumes that there is exactly one 
// missing element and may give incorrect result 
// when there is no missing element or 
// more than one missing elements. This function 
// also assumes that the difference in AP is an
// integer.
int findMissing(int arr[], int n) 
{
    // If exactly one element is missing, then we can find
    // difference of arithmetic progression using following
    // formula. Example, 2, 4, 6, 10, diff = (10-2)/4 = 2.
    // The assumption in formula is that the difference is
    // an integer.
    int diff = (arr[n - 1] - arr[0]) / n;
  
    // Binary search for the missing 
    // number using above calculated diff
    return findMissingUtil(arr, 0, n - 1, diff);
}
};
  
// Driver Code
int main()
{
    GFG g;
    int arr[] = {2, 4, 8, 10, 12, 14};
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "The missing element is " 
         << g.findMissing(arr, n);
    return 0;
} 
  
// This code is contributed by Soumik

C

// A C program to find the missing number in a given
// arithmetic progression
#include 
#include 
  
// A binary search based recursive function that returns
// the missing element in arithmetic progression
int findMissingUtil(int arr[], int low, int high, int diff)
{
    // There must be two elements to find the missing
    if (high <= low)
        return INT_MAX;
  
    // Find index of middle element
    int mid = low + (high - low)/2;
  
    // The element just after the middle element is missing.
    // The arr[mid+1] must exist, because we return when
    // (low == high) and take floor of (high-low)/2
    if (arr[mid+1] - arr[mid] != diff)
        return (arr[mid] + diff);
  
    // The element just before mid is missing
    if (mid > 0 && arr[mid] - arr[mid-1] != diff)
        return (arr[mid-1] + diff);
  
    // If the elements till mid follow AP, then recur
    // for right half
    if (arr[mid] == arr[0] + mid*diff)
        return findMissingUtil(arr, mid+1, high, diff);
  
    // Else recur for left half
    return findMissingUtil(arr, low, mid-1, diff);
}
  
// The function uses findMissingUtil() to find the missing
// element in AP.  It assumes that there is exactly one missing
// element and may give incorrect result when there is no missing
// element or more than one missing elements.
// This function also assumes that the difference in AP is an
// integer.
int findMissing(int arr[], int n)
{
    // If exactly one element is missing, then we can find
    // difference of arithmetic progression using following
    // formula.  Example, 2, 4, 6, 10, diff = (10-2)/4 = 2.
    // The assumption in formula is that the difference is
    // an integer.
    int diff = (arr[n-1] - arr[0])/n;
  
    // Binary search for the missing number using above
    // calculated diff
    return findMissingUtil(arr, 0, n-1, diff);
}
  
/* Driver program to check above functions */
int main()
{
    int arr[] = {2, 4, 8, 10, 12, 14};
    int n = sizeof(arr)/sizeof(arr[0]);
    printf("The missing element is %d", findMissing(arr, n));
    return 0;
}

Java

// A Java program to find 
// the missing number in 
// a given arithmetic 
// progression
import java.io.*;
  
class GFG 
{
      
// A binary search based 
// recursive function that 
// returns the missing 
// element in arithmetic
// progression
static int findMissingUtil(int arr[], int low, 
                           int high, int diff)
{
    // There must be two elements
    // to find the missing
    if (high <= low)
        return Integer.MAX_VALUE;
  
    // Find index of 
    // middle element
    int mid = low + (high - low) / 2;
  
    // The element just after the 
    // middle element is missing. 
    // The arr[mid+1] must exist, 
    // because we return when
    // (low == high) and take
    // floor of (high-low)/2
    if (arr[mid + 1] - arr[mid] != diff)
        return (arr[mid] + diff);
  
    // The element just 
    // before mid is missing
    if (mid > 0 && arr[mid] - 
                   arr[mid - 1] != diff)
        return (arr[mid - 1] + diff);
  
    // If the elements till mid follow 
    // AP, then recur for right half
    if (arr[mid] == arr[0] + mid * diff)
        return findMissingUtil(arr, mid + 1, 
                               high, diff);
  
    // Else recur for left half
    return findMissingUtil(arr, low, mid - 1, diff);
}
  
// The function uses findMissingUtil() 
// to find the missing element in AP. 
// It assumes that there is exactly 
// one missing element and may give 
// incorrect result when there is no 
// missing element or more than one
// missing elements. This function also 
// assumes that the difference in AP is
// an integer.
static int findMissing(int arr[], int n)
{
    // If exactly one element is missing, 
    // then we can find difference of
    // arithmetic progression using 
    // following formula. Example, 2, 4, 
    // 6, 10, diff = (10-2)/4 = 2.
    // The assumption in formula is that 
    // the difference is an integer.
    int diff = (arr[n - 1] - arr[0]) / n;
  
    // Binary search for the missing 
    // number using above calculated diff
    return findMissingUtil(arr, 0, n - 1, diff);
}
  
// Driver Code
public static void main (String[] args) 
{
    int arr[] = {2, 4, 8, 10, 12, 14};
    int n = arr.length;
    System.out.println("The missing element is "+   
                            findMissing(arr, n));
}
}
  
// This code is contributed by anuj_67.

Python3

# A Python3 program to find the missing 
# number in a given arithmetic progression 
import sys
  
# A binary search based recursive function 
# that returns the missing element in
# arithmetic progression 
def findMissingUtil(arr, low, high, diff): 
  
    # There must be two elements to 
    # find the missing 
    if (high <= low): 
        return sys.maxsize; 
  
    # Find index of middle element 
    mid = int(low + (high - low) / 2); 
  
    # The element just after the middle 
    # element is missing. The arr[mid+1] 
    # must exist, because we return when 
    # (low == high) and take floor of
    # (high-low)/2 
    if (arr[mid + 1] - arr[mid] != diff): 
        return (arr[mid] + diff); 
  
    # The element just before mid is missing 
    if (mid > 0 and arr[mid] - 
                    arr[mid - 1] != diff): 
        return (arr[mid - 1] + diff); 
  
    # If the elements till mid follow AP, 
    # then recur for right half 
    if (arr[mid] == arr[0] + mid * diff): 
        return findMissingUtil(arr, mid + 1,
                                high, diff); 
  
    # Else recur for left half 
    return findMissingUtil(arr, low,
                           mid - 1, diff); 
  
# The function uses findMissingUtil() to find 
# the missing element in AP. It assumes that 
# there is exactly one missing element and may 
# give incorrect result when there is no missing 
# element or more than one missing elements. 
# This function also assumes that the difference 
# in AP is an integer. 
def findMissing(arr, n): 
  
    # If exactly one element is missing, then 
    # we can find difference of arithmetic 
    # progression using following formula. 
    # Example, 2, 4, 6, 10, diff = (10-2)/4 = 2. 
    # The assumption in formula is that the 
    # difference is an integer. 
    diff = int((arr[n - 1] - arr[0]) / n); 
  
    # Binary search for the missing number
    # using above calculated diff 
    return findMissingUtil(arr, 0, n - 1, diff); 
  
# Driver Code
arr = [2, 4, 8, 10, 12, 14]; 
n = len(arr); 
print("The missing element is",
          findMissing(arr, n)); 
  
# This code is contributed by chandan_jnu

C#

// A C# program to find 
// the missing number in 
// a given arithmetic 
// progression
using System;
  
class GFG 
{
      
// A binary search based 
// recursive function that 
// returns the missing 
// element in arithmetic
// progression
static int findMissingUtil(int []arr, int low, 
                           int high, int diff)
{
    // There must be two elements
    // to find the missing
    if (high <= low)
        return int.MaxValue;
  
    // Find index of 
    // middle element
    int mid = low + (high - 
                     low) / 2;
  
    // The element just after the 
    // middle element is missing. 
    // The arr[mid+1] must exist, 
    // because we return when
    // (low == high) and take
    // floor of (high-low)/2
    if (arr[mid + 1] - 
        arr[mid] != diff)
        return (arr[mid] + diff);
  
    // The element just 
    // before mid is missing
    if (mid > 0 && arr[mid] - 
                   arr[mid - 1] != diff)
        return (arr[mid - 1] + diff);
  
    // If the elements till mid follow 
    // AP, then recur for right half
    if (arr[mid] == arr[0] +
               mid * diff)
        return findMissingUtil(arr, mid + 1, 
                               high, diff);
  
    // Else recur for left half
    return findMissingUtil(arr, low, 
                           mid - 1, diff);
}
  
// The function uses findMissingUtil() 
// to find the missing element 
// in AP. It assumes that there
// is exactly one missing element 
// and may give incorrect result
// when there is no missing element 
// or more than one missing elements. 
// This function also assumes that 
// the difference in AP is an integer.
static int findMissing(int []arr, int n)
{
    // If exactly one element 
    // is missing, then we can 
    // find difference of arithmetic 
    // progression using following 
    // formula. Example, 2, 4, 6, 10, 
    // diff = (10-2)/4 = 2.The assumption 
    // in formula is that the difference
    // is an integer.
    int diff = (arr[n - 1] - 
                arr[0]) / n;
  
    // Binary search for the 
    // missing number using 
    // above calculated diff
    return findMissingUtil(arr, 0, 
                           n - 1, diff);
}
  
// Driver Code
public static void Main () 
{
    int []arr = {2, 4, 8, 
                 10, 12, 14};
    int n = arr.Length;
    Console.WriteLine("The missing element is "+ 
                           findMissing(arr, n));
}
}
  
// This code is contributed by anuj_67.

PHP

 0 && $arr[$mid] - $arr[$mid - 1] != $diff) 
        return ($arr[$mid - 1] + $diff); 
  
    // If the elements till mid follow AP, 
    // then recur for right half 
    if ($arr[$mid] == $arr[0] + $mid * $diff) 
        return findMissingUtil($arr, $mid + 1, 
                               $high, $diff); 
  
    // Else recur for left half 
    return findMissingUtil($arr, $low, $mid - 1, $diff); 
} 
  
// The function uses findMissingUtil() to find 
// the missing element in AP. It assumes that 
// there is exactly one missing element and may 
// give incorrect result when there is no missing 
// element or more than one missing elements. 
// This function also assumes that the difference 
// in AP is an integer. 
function findMissing($arr, $n) 
{ 
    // If exactly one element is missing, then 
    // we can find difference of arithmetic 
    // progression using following formula. 
    // Example, 2, 4, 6, 10, diff = (10-2)/4 = 2. 
    // The assumption in formula is that the 
    // difference is an integer. 
    $diff = ($arr[$n - 1] - $arr[0]) / $n; 
  
    // Binary search for the missing number
    //  using above calculated diff 
    return findMissingUtil($arr, 0, $n - 1, $diff); 
} 
  
// Driver Code
$arr = array(2, 4, 8, 10, 12, 14); 
$n = sizeof($arr); 
echo "The missing element is ", 
         findMissing($arr, $n); 
  
// This code is contributed by Sach_Code
?>

输出：

The missing element is 6

锻炼：
解决几何级数相同的问题。您的解决方案的时间复杂度是多少?那斐波那契系列呢?