我有一个从1到100（包括两者）的数字数组。数组的大小为100.数字随机添加到数组中，但数组中有一个随机空插槽。 找到该插槽的最快捷方式是什么，以及插入插槽的数量是多少？最好使用Java解决方案。
答案 0 :(得分：129)
您可以在O（n）中执行此操作。迭代数组并计算所有数字的总和。现在，从1到N的自然数之和可以表示为Nx(N+1)/2。在你的情况下N = 100。
从Nx(N+1)/2减去数组的总和，其中N = 100。
这是缺少的数字。在迭代期间可以检测空槽，其中计算总和。
// will be the sum of the numbers in the array.
int sum = 0;
int idx = -1;
for (int i = 0; i < arr.length; i++)
{
if (arr[i] == 0)
{
idx = i;
}
else
{
sum += arr[i];
}
}
// the total sum of numbers between 1 and arr.length.
int total = (arr.length + 1) * arr.length / 2;
System.out.println("missing number is: " + (total - sum) + " at index " + idx);
答案 1 :(得分：24)
我们可以使用比求和更安全的XOR运算，因为在编程语言中如果给定的输入很大，它可能会溢出并可能给出错误的答案。
在进入解决方案之前，请知道A xor A = 0。因此，如果我们对两个相同的数字进行异或，则该值为0.
现在，对阵列中存在的元素进行异或[1..n]取消相同的数字。所以最后我们会得到丢失的号码。
// Assuming that the array contains 99 distinct integers between 1..99
// and empty slot value is zero
int XOR = 0;
for(int i=0; i<100; i++) {
if (ARRAY[i] != 0)
XOR ^= ARRAY[i];
XOR ^= (i + 1);
}
return XOR;
答案 2 :(得分：22)
让给定的数组为长度为N的A。假设在给定的数组中，单个空槽用0填充。
我们可以使用许多方法找到解决此问题的方法，包括Counting sort中使用的算法。但是，就有效的时间和空间使用而言，我们有两种算法。一个主要使用求和，减法和乘法。另一个使用XOR。数学上两种方法都可以正常工作。但是以编程方式，我们需要使用主要措施评估所有算法，例如
A[1...N]）和/或数量
输入值很大（N））等。这是因为时间和/或硬件（硬件资源限制）和/或软件（操作系统限制，编程语言限制等）等方面的限制。让我们列出并评估每一个的利弊。 / p>
在算法1中，我们有3个实现。
使用数学公式（1+2+3+...+N=(N(N+1))/2）计算所有数字的总和（包括未知缺失数）。在这里，N=100。计算所有给定数字的总和。从第一个结果中减去第二个结果将得到缺失的数字。
Missing Number = (N(N+1))/2) - (A[1]+A[2]+...+A[100])
使用数学公式（1+2+3+...+N=(N(N+1))/2）计算所有数字的总和（包括未知缺失数）。在这里，N=100。从该结果中，减去每个给定的数字给出缺失的数字。
Missing Number = (N(N+1))/2)-A[1]-A[2]-...-A[100]
（Note:尽管第二个实现的公式是从第一个派生出来的，但从数学的角度来看两者都是相同的。但是从编程的角度来看两者都是不同的，因为第一个公式更容易出现比特溢出第二个（如果给定的数字足够大）。即使加法比减法更快，第二个实现减少了由于添加大值而导致比特溢出的可能性（它没有被完全消除，因为自那以后仍有很小的机会公式中存在（N+1）。但两者同样容易因乘法而出现位溢出。限制是两种实现仅在N(N+1)<=MAXIMUM_NUMBER_VALUE时给出正确的结果。对于第一次实现，附加限制是只有在Sum of all given numbers<=MAXIMUM_NUMBER_VALUE时才会给出正确的结果。）
计算所有数字的总和（包括未知缺失数）并并行地减去同一循环中的每个给定数字。这消除了乘法导致位溢出的风险，但是通过加法和减法容易出现位溢出。
//ALGORITHM
missingNumber = 0;
foreach(index from 1 to N)
{
missingNumber = missingNumber + index;
//Since, the empty slot is filled with 0,
//this extra condition which is executed for N times is not required.
//But for the sake of understanding of algorithm purpose lets put it.
if (inputArray[index] != 0)
missingNumber = missingNumber - inputArray[index];
}
在编程语言（如C，C ++，Java等）中，如果表示整数数据类型的位数有限，则由于求和，减法和乘法，所有上述实现都容易出现位溢出，从而导致输入值较大（A[1...N]）和/或输入值较大（N）时输入错误。
我们可以使用XOR的属性来解决这个问题，而不用担心位溢出的问题。而且XOR比求和更安全，更快。我们知道XOR的属性是两个相同数字的XOR等于0（A XOR A = 0）。如果我们计算从1到N的所有数字的XOR（这包括未知的缺失数字）然后使用该结果，对所有给定的数字进行异或，则公共数字被取消（从A XOR A=0开始）并且在最后我们得到了丢失的号码。如果我们没有位溢出问题，我们可以使用求和和基于XOR的算法来获得解决方案。但是，使用XOR的算法比使用求和，减法和乘法的算法更安全，更快速。并且我们可以避免由求和，减法和乘法引起的额外担忧。
在算法1的所有实现中，我们可以使用XOR而不是加法和减法。
让我们假设，XOR(1...N) = XOR of all numbers from 1 to N
实施1 =＆gt; Missing Number = XOR(1...N) XOR (A[1] XOR A[2] XOR...XOR A[100])
实施2 =＆gt; Missing Number = XOR(1...N) XOR A[1] XOR A[2] XOR...XOR A[100]
实施3 =＆gt;
//ALGORITHM
missingNumber = 0;
foreach(index from 1 to N)
{
missingNumber = missingNumber XOR index;
//Since, the empty slot is filled with 0,
//this extra condition which is executed for N times is not required.
//But for the sake of understanding of algorithm purpose lets put it.
if (inputArray[index] != 0)
missingNumber = missingNumber XOR inputArray[index];
}
算法2的所有三种实现都可以正常工作（从编程的角度来看也是如此）。一个优化类似于
1+2+....+N = (N(N+1))/2
我们有，
1 XOR 2 XOR .... XOR N = {N if REMAINDER(N/4)=0, 1 if REMAINDER(N/4)=1, N+1 if REMAINDER(N/4)=2, 0 if REMAINDER(N/4)=3}
我们可以通过数学归纳证明这一点。因此，我们可以使用这个公式来减少XOR运算的数量，而不是通过XOR计算从1到N的XOR（1 ... N）的值，我们可以使用这个公式来减少XOR运算的数量。
此外，使用上述公式计算XOR（1 ... N）有两种实现方式。实施明智，计算
// Thanks to https://a3nm.net/blog/xor.html for this implementation
xor = (n>>1)&1 ^ (((n&1)>0)?1:n)
比计算
更快xor = (n % 4 == 0) ? n : (n % 4 == 1) ? 1 : (n % 4 == 2) ? n + 1 : 0;
因此，优化的Java代码是
long n = 100;
long a[] = new long[n];
//XOR of all numbers from 1 to n
// n%4 == 0 ---> n
// n%4 == 1 ---> 1
// n%4 == 2 ---> n + 1
// n%4 == 3 ---> 0
//Slower way of implementing the formula
// long xor = (n % 4 == 0) ? n : (n % 4 == 1) ? 1 : (n % 4 == 2) ? n + 1 : 0;
//Faster way of implementing the formula
// long xor = (n>>1)&1 ^ (((n&1)>0)?1:n);
long xor = (n>>1)&1 ^ (((n&1)>0)?1:n);
for (long i = 0; i < n; i++)
{
xor = xor ^ a[i];
}
//Missing number
System.out.println(xor);
答案 3 :(得分：17)
这是一个亚马逊的采访问题，最初在这里回答：We have numbers from 1 to 52 that are put into a 51 number array, what's the best way to find out which number is missing?
答案如下：
1) Calculate the sum of all numbers stored in the array of size 51.
2) Subtract the sum from (52 * 53)/2 ---- Formula : n * (n + 1) / 2.
答案 4 :(得分：9)
这是一个在整数数组中找到缺失数字的简单程序
ArrayList<Integer> arr = new ArrayList<Integer>();
int a[] = { 1,3,4,5,6,7,10 };
int j = a[0];
for (int i=0;i<a.length;i++)
{
if (j==a[i])
{
j++;
continue;
}
else
{
arr.add(j);
i--;
j++;
}
}
System.out.println("missing numbers are ");
for(int r : arr)
{
System.out.println(" " + r);
}
答案 5 :(得分：6)
5050 - （数组中所有值的总和）=缺少数字
int sum = 0;
int idx = -1;
for (int i = 0; i < arr.length; i++) {
if (arr[i] == 0) idx = i; else sum += arr[i];
}
System.out.println("missing number is: " + (5050 - sum) + " at index " + idx);
答案 6 :(得分：4)
在类似的情况下，数组已经排序，它不包含重复项，只缺少一个数字，可以在log（n）中找到此缺失的数字时间，使用二分搜索。
public static int getMissingInt(int[] intArray, int left, int right) {
if (right == left + 1) return intArray[right] - 1;
int pivot = left + (right - left) / 2;
if (intArray[pivot] == intArray[left] + (intArray[right] - intArray[left]) / 2 - (right - left) % 2)
return getMissingInt(intArray, pivot, right);
else
return getMissingInt(intArray, left, pivot);
}
public static void main(String args[]) {
int[] array = new int[]{3, 4, 5, 6, 7, 8, 10};
int missingInt = getMissingInt(array, 0, array.length-1);
System.out.println(missingInt); //it prints 9
}
答案 7 :(得分：3)
最近我在求职面试中遇到了一个类似的（不完全相同的）问题，我也听到一位朋友在接受采访时被问到完全相同的问题。 所以这里是OP问题的答案以及可能会被问到的一些变化。 答案示例在 Java 中给出，因为它声明：
最好使用Java解决方案。
变体1：
1到100之间的数字数组（包括两者）......数字随机添加到数组中，但数组中有一个随机空插槽
public static int findMissing1(int [] arr){
int sum = 0;
for(int n : arr){
sum += n;
}
return (100*(100+1)/2) - sum;
}
<强>说明：
此解决方案（此处发布的许多其他解决方案）基于Triangular number的公式，它为我们提供从1到n的所有自然数的总和（在这种情况下，n为100 ）。现在我们知道应该从1到100的总和 - 我们只需要减去给定数组中现有数字的实际总和。
变体2：
从1到n的数字数组（表示最大数字未知）
public static int findMissing2(int [] arr){
int sum = 0, max = 0;
for(int n : arr){
sum += n;
if(n > max) max = n;
}
return (max*(max+1)/2) - sum;
}
<强>说明： 在这个解决方案中，由于没有给出最大数量 - 我们需要找到它。找到最大数量后 - 逻辑是相同的。
变体3：
从1到n的数字数组（最大数字未知），数组中有两个随机空插槽
public static int [] findMissing3(int [] arr){
int sum = 0, max = 0, misSum;
int [] misNums = {};//empty by default
for(int n : arr){
sum += n;
if(n > max) max = n;
}
misSum = (max*(max+1)/2) - sum;//Sum of two missing numbers
for(int n = Math.min(misSum, max-1); n > 1; n--){
if(!contains(n, arr)){
misNums = new int[]{n, misSum-n};
break;
}
}
return misNums;
}
private static boolean contains(int num, int [] arr){
for(int n : arr){
if(n == num)return true;
}
return false;
}
<强>说明：
在此解决方案中，不给出最大数量（如前所述），但也可能缺少两个数字而不是一个数字。因此，首先我们找到缺失数字的总和 - 使用与以前相同的逻辑。第二个发现缺失金额和最后（可能）缺失数字之间的较小数字 - 以减少不必要的搜索。第三，因为Java的数组（不是集合）没有indexOf或contains的方法，我为该逻辑添加了一个小的可重用方法。第四，当找到第一个缺失的数字时，第二个是从缺失的总和中减去。
如果只缺少一个数字，则数组中的第二个数字将为零。
变体4：
从1到n的数字数组（最大数量未知），缺少X（缺失数量未知）
public static ArrayList<Integer> findMissing4(ArrayList<Integer> arr){
int max = 0;
ArrayList<Integer> misNums = new ArrayList();
int [] neededNums;
for(int n : arr){
if(n > max) max = n;
}
neededNums = new int[max];//zero for any needed num
for(int n : arr){//iterate again
neededNums[n == max ? 0 : n]++;//add one - used as index in second array (convert max to zero)
}
for(int i=neededNums.length-1; i>0; i--){
if(neededNums[i] < 1)misNums.add(i);//if value is zero, than index is a missing number
}
return misNums;
}
<强>说明：
在此解决方案中，与之前一样，最大数量未知且可能缺少多个数字，但在此变体中，我们不知道可能缺少多少数字（如果有）。逻辑的开头是相同的 - 找到最大数字。然后我用零初始化另一个数组，在这个数组中index表示可能缺少的数字，零表示该数字丢失。因此，原始数组中的每个现有数字都用作索引，其值增加1（最大值转换为零）。
注意
如果您想要其他语言中的示例或此问题的其他有趣的变体，欢迎您查看我的Github存储库以查找Interview questions & answers
答案 8 :(得分：3)
好吧，使用布隆过滤器。
int findmissing(int arr[], int n)
{
long bloom=0;
int i;
for(i=0; i<;n; i++)bloom+=1>>arr[i];
for(i=1; i<=n, (bloom<<i & 1); i++);
return i;
}
答案 9 :(得分：2)
不涉及重复添加或n（n + 1）/ 2公式的解决方案在访谈时间没有找到你。
您必须使用4个整数（32位）或2个整数（64位）的数组。用（-1＆amp;〜（1＆lt;＆lt; 31））＆gt;＆gt;初始化最后一个int。 3.（高于100的位设置为1）或者您可以使用for循环将位设置为100以上。
public int MissingNumber(int a[])
{
int bits = sizeof(int) * 8;
int i = 0;
int no = 0;
while(a[i] == -1)//this means a[i]'s bits are all set to 1, the numbers is not inside this 32 numbers section
{
no += bits;
i++;
}
return no + bits - Math.Log(~a[i], 2);//apply NOT (~) operator to a[i] to invert all bits, and get a number with only one bit set (2 at the power of something)
}
示例：（32位版本）假设丢失的数字为58.这意味着第二个整数的第26位（从左到右）设置为0.
第一个int是-1（所有位都已设置）所以，我们继续第二个并添加到“no”数字32.第二个int不同于-1（未设置位）所以通过将NOT（〜）运算符应用于我们得到的数字64.在幂x处可能的数字是2，我们可以通过使用log on base 2计算x;在这种情况下，我们得到log2（64）= 6 =＆gt; 32 + 32 - 6 = 58。
希望这有帮助。
答案 10 :(得分：2)
这是c＃但它应该非常接近你需要的东西：
int sumNumbers = 0;
int emptySlotIndex = -1;
for (int i = 0; i < arr.length; i++)
{
if (arr[i] == 0)
emptySlotIndex = i;
sumNumbers += arr[i];
}
int missingNumber = 5050 - sumNumbers;
答案 11 :(得分：1)
从一系列数字中找出缺失的数字。 IMP指出要记住。
序列必须是AP。
public int execute2(int[] array) {
int diff = Math.min(array[1]-array[0], array[2]-array[1]);
int min = 0, max = arr.length-1;
boolean missingNum = true;
while(min<max) {
int mid = (min + max) >>> 1;
int leftDiff = array[mid] - array[min];
if(leftDiff > diff * (mid - min)) {
if(mid-min == 1)
return (array[mid] + array[min])/2;
max = mid;
missingNum = false;
continue;
}
int rightDiff = array[max] - array[mid];
if(rightDiff > diff * (max - mid)) {
if(max-mid == 1)
return (array[max] + array[mid])/2;
min = mid;
missingNum = false;
continue;
}
if(missingNum)
break;
}
return -1;
}
答案 12 :(得分：1)
我认为最简单且可能最有效的解决方案是循环遍历所有条目并使用bitset来记住设置了哪些数字，然后测试0位。 0位的输入是缺失的数字。
答案 13 :(得分：1)
function solution($A) {
// code in PHP5.5
$n=count($A);
for($i=1;$i<=$n;$i++) {
if(!in_array($i,$A)) {
return (int)$i;
}
}
}
答案 14 :(得分：1)
我在这里找到了这个美丽的解决方案：
http://javaconceptoftheday.com/java-puzzle-interview-program-find-missing-number-in-an-array/
public class MissingNumberInArray
{
//Method to calculate sum of 'n' numbers
static int sumOfNnumbers(int n)
{
int sum = (n * (n+1))/ 2;
return sum;
}
//Method to calculate sum of all elements of array
static int sumOfElements(int[] array)
{
int sum = 0;
for (int i = 0; i < array.length; i++)
{
sum = sum + array[i];
}
return sum;
}
public static void main(String[] args)
{
int n = 8;
int[] a = {1, 4, 5, 3, 7, 8, 6};
//Step 1
int sumOfNnumbers = sumOfNnumbers(n);
//Step 2
int sumOfElements = sumOfElements(a);
//Step 3
int missingNumber = sumOfNnumbers - sumOfElements;
System.out.println("Missing Number is = "+missingNumber);
}
}
答案 15 :(得分：0)
以下是查找给定数组中所有缺失数字的解决方案：
public class FindMissingNumbers {
/**
* The function prints all the missing numbers from "n" consecutive numbers.
* The number of missing numbers is not given and all the numbers in the
* given array are assumed to be unique.
*
* A similar approach can be used to find all no-unique/ unique numbers from
* the given array
*
* @param n
* total count of numbers in the sequence
* @param numbers
* is an unsorted array of all the numbers from 1 - n with some
* numbers missing.
*
*/
public static void findMissingNumbers(int n, int[] numbers) {
if (n < 1) {
return;
}
byte[] bytes = new byte[n / 8];
int countOfMissingNumbers = n - numbers.length;
if (countOfMissingNumbers == 0) {
return;
}
for (int currentNumber : numbers) {
int byteIndex = (currentNumber - 1) / 8;
int bit = (currentNumber - byteIndex * 8) - 1;
// Update the "bit" in bytes[byteIndex]
int mask = 1 << bit;
bytes[byteIndex] |= mask;
}
for (int index = 0; index < bytes.length - 2; index++) {
if (bytes[index] != -128) {
for (int i = 0; i < 8; i++) {
if ((bytes[index] >> i & 1) == 0) {
System.out.println("Missing number: " + ((index * 8) + i + 1));
}
}
}
}
// Last byte
int loopTill = n % 8 == 0 ? 8 : n % 8;
for (int index = 0; index < loopTill; index++) {
if ((bytes[bytes.length - 1] >> index & 1) == 0) {
System.out.println("Missing number: " + (((bytes.length - 1) * 8) + index + 1));
}
}
}
public static void main(String[] args) {
List<Integer> arrayList = new ArrayList<Integer>();
int n = 128;
int m = 5;
for (int i = 1; i <= n; i++) {
arrayList.add(i);
}
Collections.shuffle(arrayList);
for (int i = 1; i <= 5; i++) {
System.out.println("Removing:" + arrayList.remove(i));
}
int[] array = new int[n - m];
for (int i = 0; i < (n - m); i++) {
array[i] = arrayList.get(i);
}
System.out.println("Array is: " + Arrays.toString(array));
findMissingNumbers(n, array);
}
}
答案 16 :(得分：0)
simple solution with test data :
class A{
public static void main(String[] args){
int[] array = new int[200];
for(int i=0;i<100;i++){
if(i != 51){
array[i] = i;
}
}
for(int i=100;i<200;i++){
array[i] = i;
}
int temp = 0;
for(int i=0;i<200;i++){
temp ^= array[i];
}
System.out.println(temp);
}
}
答案 17 :(得分：0)
使用和公式，
class Main {
// Function to ind missing number
static int getMissingNo (int a[], int n) {
int i, total;
total = (n+1)*(n+2)/2;
for ( i = 0; i< n; i++)
total -= a[i];
return total;
}
/* program to test above function */
public static void main(String args[]) {
int a[] = {1,2,4,5,6};
int miss = getMissingNo(a,5);
System.out.println(miss);
}
}
答案 18 :(得分：0)
public class MissingNumber {
public static void main(String[] args) {
int array[] = {1,2,3,4,6};
int x1 = getMissingNumber(array,6);
System.out.println("The Missing number is: "+x1);
}
private static int getMissingNumber(int[] array, int i) {
int acctualnumber =0;
int expectednumber = (i*(i+1)/2);
for (int j : array) {
acctualnumber = acctualnumber+j;
}
System.out.println(acctualnumber);
System.out.println(expectednumber);
return expectednumber-acctualnumber;
}
}
答案 19 :(得分：0)
此处程序占用时间复杂度为O（logn）和空间复杂度O（logn）
public class helper1 {
public static void main(String[] args) {
int a[] = {1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12};
int k = missing(a, 0, a.length);
System.out.println(k);
}
public static int missing(int[] a, int f, int l) {
int mid = (l + f) / 2;
//if first index reached last then no element found
if (a.length - 1 == f) {
System.out.println("missing not find ");
return 0;
}
//if mid with first found
if (mid == f) {
System.out.println(a[mid] + 1);
return a[mid] + 1;
}
if ((mid + 1) == a[mid])
return missing(a, mid, l);
else
return missing(a, f, mid);
}
}
答案 20 :(得分：0)
========排序数组的最简单解决方案===========
public int getMissingNumber(int[] sortedArray)
{
int missingNumber = 0;
int missingNumberIndex=0;
for (int i = 0; i < sortedArray.length; i++)
{
if (sortedArray[i] == 0)
{
missingNumber = (sortedArray[i + 1]) - 1;
missingNumberIndex=i;
System.out.println("missingNumberIndex: "+missingNumberIndex);
break;
}
}
return missingNumber;
}
答案 21 :(得分：0)
解决方案使用PHP $ n = 100 ;
$n*($n+1)/2 - array_sum($array) = $missing_number
和array_search($missing_number)将提供缺失数字的索引
答案 22 :(得分：0)
假设你有n为8，本例中我们的数字范围为0-8 我们可以表示所有9个数字的二进制表示如下 0000 0001 0010 0011 0100 0101 0110 0111 1000
在上面的序列中没有丢失的数字，并且在每列中零和1的数量匹配，但是一旦你删除1值，我们就说3我们在列的0和1的数量上取得平衡。如果列中的0的数量是＆lt; = 1的数量，则我们缺少的数字在该位位置将具有0，否则如果0的数量> 0。在这个位的位数为1，那么这个位的位置是1.我们测试从左到右的位，在每次迭代时，我们丢弃一半的数组用于测试下一位，即奇数数组值或者偶数数组值在每次迭代时被丢弃，这取决于我们缺少哪个位。
以下解决方案是在C ++中
int getMissingNumber(vector<int>* input, int bitPos, const int startRange)
{
vector<int> zeros;
vector<int> ones;
int missingNumber=0;
//base case, assume empty array indicating start value of range is missing
if(input->size() == 0)
return startRange;
//if the bit position being tested is 0 add to the zero's vector
//otherwise to the ones vector
for(unsigned int i = 0; i<input->size(); i++)
{
int value = input->at(i);
if(getBit(value, bitPos) == 0)
zeros.push_back(value);
else
ones.push_back(value);
}
//throw away either the odd or even numbers and test
//the next bit position, build the missing number
//from right to left
if(zeros.size() <= ones.size())
{
//missing number is even
missingNumber = getMissingNumber(&zeros, bitPos+1, startRange);
missingNumber = (missingNumber << 1) | 0;
}
else
{
//missing number is odd
missingNumber = getMissingNumber(&ones, bitPos+1, startRange);
missingNumber = (missingNumber << 1) | 1;
}
return missingNumber;
}
在每次迭代中，我们将输入空间减少2，即N，N / 2，N / 4 ... = O（log N），空间为O（N）
//Test cases
[1] when missing number is range start
[2] when missing number is range end
[3] when missing number is odd
[4] when missing number is even
答案 23 :(得分：0)
您可以做的一件事就是使用快速排序对数字进行排序。然后使用for循环遍历排序数组，从1到100.在每次迭代中，将数组中的数字与for循环增量进行比较，如果发现索引增量与数组值不同，则找到了您丢失的号码以及缺失的索引。
答案 24 :(得分：0)
本程序发现缺少数字
<?php
$arr_num=array("1","2","3","5","6");
$n=count($arr_num);
for($i=1;$i<=$n;$i++)
{
if(!in_array($i,$arr_num))
{
array_push($arr_num,$i);print_r($arr_num);exit;
}
}
?>
答案 25 :(得分：-1)
现在我现在对Big O符号太过尖锐了，但是你也不能做类似的事情（在Java中）
for (int i = 0; i < numbers.length; i++) {
if(numbers[i] != i+1){
System.out.println(i+1);
}
}
其中number是数字从1-100开始的数组。 从我对这个问题的解读中，它没有说明何时写出缺失的数字。
或者，如果您可以将i + 1的值抛出到另一个数组中并在迭代后将其打印出来。
当然，它可能不遵守时间和空间规则。就像我说的。我必须强烈要求大O.
答案 26 :(得分：-1)
如果数组是随机填充的，那么最好能够以O（n）复杂度进行线性搜索。但是，我们可以通过分割和征服方法将复杂度提高到O（log n），类似于giri指出的快速排序，因为数字是按升序/降序排列的。
答案 27 :(得分：-1)
//Array is shorted and if writing in C/C++ think of XOR implementations in java as follows.
int num=-1;
for (int i=1; i<=100; i++){
num =2*i;
if(arr[num]==0){
System.out.println("index: "+i+" Array position: "+ num);
break;
}
else if(arr[num-1]==0){
System.out.println("index: "+i+ " Array position: "+ (num-1));
break;
}
}// use Rabbit and tortoise race, move the dangling index faster,
//learnt from Alogithimica, Ameerpet, hyderbad**
答案 28 :(得分：-5)
另一个家庭作业问题。顺序搜索是您可以做的最好的。至于Java解决方案，请考虑为读者练习。 ：P
答案 29 :(得分：-7)
快速排序是最高效率的最佳选择....