Question

我发现这个JavaScript算法练习：

问题：

从排除数字1到100的未排序数组（不包括一个数字），您将如何找到该数字？

作者提供的解决方案是：

function missingNumber(arr) {
    var n = arr.length + 1,
        sum = 0,
        expectedSum = n * (n + 1) / 2;

    for (var i = 0, len = arr.length; i < len; i++) {
        sum += arr[i];
    }

    return expectedSum - sum;
}

我想尝试制作它，以便找到多个缺失的数字。

我的解决方案：

var someArr = [2, 5, 3, 1, 4, 7, 10, 15]

function findMissingNumbers(arr) {
    var missingNumbersCount;
    var missingNumbers = [];
    arr.sort(function(a, b) {
        return a - b;
    })  
    for(var i = 0; i < arr.length; i++) {
        if(arr[i+1] - arr[i] != 1 && arr[i+1] != undefined) {
            missingNumbersCount = arr[i+1] - arr[i] - 1;
            for(j = 1; j <= missingNumbersCount; j++) {
                missingNumbers.push(arr[i] + j)
            }
        }
    }
    return missingNumbers
}

findMissingNumbers(someArr) // [6, 8, 9, 11, 12, 13, 14]

有更好的方法吗？它必须是 JavaScript ，因为那是我正在练习的。

Answer 1

此问题的最简单解决方案

miss = (arr) => {
    let missArr=[];
    let l = Math.max(...arr);
    for(i=1;i<l;i++) {
        if(arr.indexOf(i)<0) {
            missArr.push(i);
        }
    }
    return missArr;
}
miss([3,4,1,2,6,8,12]);

Answer 2

这样的事情会做你想要的。

    var X = [2, 5, 3, 1, 4, 7, 10, 15]; // Array of numbers
    var N = Array.from(Array(Math.max.apply(Math, X)).keys()); //Generate number array using the largest int from X
    
    Array.prototype.diff = function(a) {
        return this.filter(function(i) {return a.indexOf(i) < 0;}); //Return the difference
    }; 
    console.log(N.diff(X));

Answer 3

您可以在与输入数组中的值对应的索引处使用具有1值的稀疏数组。然后你可以创建另一个包含所有数字的数组（与稀疏数组的长度相同），并且只保留那些与稀疏数组中具有1值的索引相对应的值。

这将在 O（n）时间内运行：

function findMissingNumbers(arr) {
    // Create sparse array with a 1 at each index equal to a value in the input.
    var sparse = arr.reduce((sparse, i) => (sparse[i]=1,sparse), []);
    // Create array 0..highest number, and retain only those values for which
    // the sparse array has nothing at that index (and eliminate the 0 value).
    return [...sparse.keys()].filter(i => i && !sparse[i]);
}

var someArr = [2, 5, 3, 1, 4, 7, 10, 15]
var result = findMissingNumbers(someArr);
console.log(result);

注意：这需要EcmaScript2015支持。

Answer 4

Option 1: 
1. create a binary array
2. iterate over input array and for each element mark binary array true.
3. iterate over binary array and find out numbers of false.

Time complexity = O(N)
Space complexity = N

Option 2:
Sort input array O(nLogn)
iterate over sorted array and identify missing number a[i+1]-a[i] > 0
O(n)

total time complexity = O(nlogn) + O(n)

Answer 5

您可以尝试以下方法：

let missingNum= (n) => {
    return n
        .sort((a, b) => a - b)
        .reduce((r, v, i, a) =>
            (l => r.concat(Array.from({ length: v - l - 1 }, _ => ++l)))(a[i - 1]),
            []
        )
}

console.log(missingNum([1,2,3,4,10]));

Answer 6

从未排序的数组或包含重复值的数组中查找缺失数字的解决方案。

data = pd.DataFrame({
sheet name': ['sheet 1', 'sheet 2', 'sheet 3', 'sheet 4','sheet5'],
'start date': ['1988/01/12', '1988/01/13', '1988/01/14', '1989/01/20','1990/01/01'],
'end date': ['1989/01/12', '1989/01/12', '1989/01/12', '1990/01/20','1991/01/01'],
'missing values': [3, 10, 1, 43, 8]
})

Answer 7

我的解决方案使用与trincot's answer相同的逻辑

时间复杂度为 O（n）

const check_miss = (n) => {
  let temp = Array(Math.max(...n)).fill(0);

  n.forEach((item) => (temp[item] = 1));

  const missing_items = temp
    .map((item, index) => (item === 0 ? index : -1))
    .filter((item) => item !== -1);

  console.log(missing_items);
};

n = [5, 4, 2, 1, 10, 20, 0];
check_miss(n);

Answer 8

从数组中找到最大的数字。
继续循环搜索数字。

如果存在则返回true或false

public static void missing()
{
int[] num={3,99,1,6,7,2,100,110};
String miss="";
boolean exist=false;
int max=max(num);

for(int i=0;i<=max;i++)
{
    //System.out.println("Checking for "+i);
    exist=false;
    for(int j=0;j<=num.length-1;j++)
    {
        if(i==num[j])
        {
            //System.out.println(i+" exist");
            exist=true;
        }
    }
    if(!exist)
    {
        //System.out.println(i + "does not exist");
        miss+=Integer.toString(i)+",";
    }

}
System.out.println("Missing numbers are : "+miss);}

Answer 9

我认为对单个缺失数字不进行任何迭代的最佳方法是仅使用求和方法。

const arr=[1-100];


let total=n*(n+1)/2;


let totalarray=array.reduce((t,i)=>t+i);

console.log(total-totalarray);

从未排序的数组

9 个答案: