数组中缺少某个数字的出现，使得相邻元素的最大绝对差最小

给定一个由一些正整数组成的数组arr[]和一个由 -1 表示的特定整数的缺失出现，任务是找到缺失的数字，使得相邻元素之间的最大绝对差异最小。
例子：

Input: arr[] = {-1, 10, -1, 12, -1} 
Output: 11 
Explanation: 
Differences of Adjacent elements – 
=> a[0] – a[1] = 11 – 10 = 1 
=> a[2] – a[1] = 11 – 10 = 1 
=> a[3] – a[2] = 12 – 11 = 1 
=> a[3] – a[4] = 12 – 11 = 1 
Maximum absolute difference of adjacent elements – 2 
Input: arr[] = {1,-1, 7, 5, 2, -1, 5} 
Output: 4 
Explanation: 
Differences of Adjacent elements – 
=> a[1] – a[0] = 4 – 1 = 3 
=> a[2] – a[1] = 7 – 4 = 3 
=> a[2] – a[3] = 7 – 5 = 2 
=> a[3] – a[4] = 5 – 2 = 3 
=> a[5] – a[4] = 4 – 2 = 2 
=> a[6] – a[5] = 5 – 4 = 1 
Maximum absolute difference of adjacent elements – 3

方法：思想是找到缺失数的最大和最小相邻元素，缺失数可以是这两个值的平均值，使得最大绝对差最小。

=> max = Maximum adjacent element
=> min = Minimum adjacent element

Missing number = (max + min)
                -------------
                      2

下面是上述方法的实现：

C++

// C++ implementation of the missing
// number such that maximum absolute
// difference between adjacent element
// is minimum
 
#include 
 
using namespace std;
 
// Function to find the missing
// number such that maximum
// absolute difference is minimum
int missingnumber(int n, int arr[])
{
    int mn = INT_MAX, mx = INT_MIN;
    // Loop to find the maximum and
    // minimum adjacent element to
    // missing number
    for (int i = 0; i < n; i++) {
 
        if (i > 0 && arr[i] == -1 &&
                 arr[i - 1] != -1) {
            mn = min(mn, arr[i - 1]);
            mx = max(mx, arr[i - 1]);
        }
 
        if (i < (n - 1) && arr[i] == -1 &&
                       arr[i + 1] != -1) {
            mn = min(mn, arr[i + 1]);
            mx = max(mx, arr[i + 1]);
        }
    }
     
    long long int res = (mx + mn) / 2;
    return res;
}
 
// Driver Code
int main()
{
    int n = 5;
    int arr[5] = { -1, 10, -1,
                       12, -1 };
    int ans = 0;
     
    // Function Call
    int res = missingnumber(n, arr);
    cout << res;
 
    return 0;
}

Java

// Java implementation of the missing
// number such that maximum absolute
// difference between adjacent element
// is minimum
import java.util.*;
class GFG{
 
// Function to find the missing
// number such that maximum
// absolute difference is minimum
static int missingnumber(int n, int arr[])
{
    int mn = Integer.MAX_VALUE,
        mx = Integer.MIN_VALUE;
     
    // Loop to find the maximum and
    // minimum adjacent element to
    // missing number
    for (int i = 0; i < n; i++)
    {
        if (i > 0 && arr[i] == -1 &&
                     arr[i - 1] != -1)
        {
            mn = Math.min(mn, arr[i - 1]);
            mx = Math.max(mx, arr[i - 1]);
        }
 
        if (i < (n - 1) && arr[i] == -1 &&
                           arr[i + 1] != -1)
        {
            mn = Math.min(mn, arr[i + 1]);
            mx = Math.max(mx, arr[i + 1]);
        }
    }
     
    int res = (mx + mn) / 2;
    return res;
}
 
// Driver Code
public static void main(String[] args)
{
    int n = 5;
    int arr[] = { -1, 10, -1,
                    12, -1 };
 
    // Function Call
    int res = missingnumber(n, arr);
    System.out.print(res);
}
}
 
// This code is contributed by 29AjayKumar

Python3

# Python3 implementation of the missing
# number such that maximum absolute
# difference between adjacent element
# is minimum
import sys
 
# Function to find the missing
# number such that maximum
# absolute difference is minimum
def missingnumber(n, arr) -> int:
     
    mn = sys.maxsize;
    mx = -sys.maxsize - 1;
 
    # Loop to find the maximum and
    # minimum adjacent element to
    # missing number
    for i in range(n):
        if (i > 0 and arr[i] == -1 and
                      arr[i - 1] != -1):
            mn = min(mn, arr[i - 1]);
            mx = max(mx, arr[i - 1]);
 
        if (i < (n - 1) and arr[i] == -1 and
                            arr[i + 1] != -1):
            mn = min(mn, arr[i + 1]);
            mx = max(mx, arr[i + 1]);
 
    res = (mx + mn) / 2;
     
    return res;
 
# Driver Code
if __name__ == '__main__':
     
    n = 5;
    arr = [ -1, 10, -1, 12, -1 ];
 
    # Function call
    res = missingnumber(n, arr);
    print(res);
 
# This code is contributed by amal kumar choubey

C#

// C# implementation of the missing
// number such that maximum absolute
// difference between adjacent element
// is minimum
using System;
class GFG{
 
// Function to find the missing
// number such that maximum
// absolute difference is minimum
static int missingnumber(int n, int []arr)
{
    int mn = Int32.MaxValue,
        mx = Int32.MinValue;
     
    // Loop to find the maximum and
    // minimum adjacent element to
    // missing number
    for (int i = 0; i < n; i++)
    {
        if (i > 0 && arr[i] == -1 &&
                     arr[i - 1] != -1)
        {
            mn = Math.Min(mn, arr[i - 1]);
            mx = Math.Max(mx, arr[i - 1]);
        }
 
        if (i < (n - 1) && arr[i] == -1 &&
                           arr[i + 1] != -1)
        {
            mn = Math.Min(mn, arr[i + 1]);
            mx = Math.Max(mx, arr[i + 1]);
        }
    }
     
    int res = (mx + mn) / 2;
    return res;
}
 
// Driver Code
public static void Main()
{
    int n = 5;
    int []arr = new int[]{ -1, 10, -1, 12, -1 };
 
    // Function Call
    int res = missingnumber(n, arr);
    Console.WriteLine(res);
}
}
 
// This code is contributed by Nidhi_biet

Javascript

 
// JavaScript implementation of the missing
// number such that maximum absolute
// difference between adjacent element
// is minimum
 
// Function to find the missing
// number such that maximum
// absolute difference is minimum
function missingnumber(n, arr)
{
    let mn = 10000;
    let mx = -10000;
 
    // Loop to find the maximum and
    // minimum adjacent element to
    // missing number
    for (let i = 0; i < n; i++)
    {
        if (i > 0 && arr[i] == -1 && arr[i - 1] != -1)
        {
            mn = Math.min(mn, arr[i - 1]);
            mx = Math.max(mx, arr[i - 1]);
        }
 
        if (i < (n - 1) && arr[i] == -1 &&
                        arr[i + 1] != -1)
        {
            mn = Math.min(mn, arr[i + 1]);
            mx = Math.max(mx, arr[i + 1]);
        }
    }
 
    let res = (mx + mn) / 2;
    return res;
}
 
// Driver Code
 
let n = 5;
let arr = [-1, 10, -1, 12, -1];
 
// Function Call
let res = missingnumber(n, arr);
 
document.write(res);
 
 

输出：

11

时间复杂度： O(N)
辅助空间： O(1)