从javascript中的所有嵌套数组中找到最大和最小元素

问题描述 投票：0回答：9

我有一个像这样的数组：

var arr = [[12,45,75], [54,45,2],[23,54,75,2]];

我想找出嵌套数组中所有元素中最大的元素和最小的元素：

最小值应为：2

和

最大应该是75

我尝试了以下功能，但它们不起作用：

    function Max(arrs)
    {
        if (!arrs || !arrs.length) return undefined;
        let max = Math.max.apply(window, arrs[0]), m,
            f = function(v){ return !isNaN(v); };
        for (let i = 1, l = arrs.length; i<l; i++) {
            if ((m = Math.max.apply(window, arrs[i].filter(f)))>max) max=m;
        }
        return max;
    }
    function Min(arrs)
    {
        if (!arrs || !arrs.length) return undefined;
        let min = Math.min.apply(window, arrs[0]), m,
            f = function(v){ return !isNaN(v); };
        for (let i = 1, l = arrs.length; i<l; i++) {
            if ((m = Math.min.apply(window, arrs[i].filter(f)))>min) min=m;
        }
        return min;
    }

它给出的最大值为 75，最小值为 12。

任何指导将不胜感激。

还尝试了其他答案，但没有帮助。

Merge/flatten an array of arrays in JavaScript?的答案解决了合并数组的问题。

而我的问题是保持数组不变并执行操作。

javascript arrays max min
9个回答
27
投票

假设ES6

const arr = [[12,45,75], [54,45,2],[23,54,75,2]];

const max = Math.max(...[].concat(...arr));

const min = Math.min(...[].concat(...arr));

console.log(max);

console.log(min);

6
投票

您可以先展平数组（优点 - 适用于多层嵌套数组）

var flattenedArr = [[12,45,75], [54,45,2],[23,54,75,2] ].toString().split(",").map(Number);

然后从

展平数组中获取
min
和
max

var max = Math.max.apply( null, flattenedArr );
var min = Math.min.apply( null, flattenedArr );

演示

var flattenedArr = [
  [12, 45, 75],
  [54, 45, 2],
  [23, 54, 75, 2]
].toString().split(",").map(Number);

var max = Math.max.apply(null, flattenedArr);
var min = Math.min.apply(null, flattenedArr);

console.log(max, min);

2
投票

2024 年更新

获取一个平面数组并通过扩展值来获取最小值或最大值。

const
    values = [[12, 45, 75], [54, 45, 2], [23, 54, 75, 2]],
    flat = values.flat(),
    min = Math.min(...flat),
    max = Math.max(...flat);

console.log(min);
console.log(max);

通过检查类型的 ES5 递归方法。它适用于深度嵌套数组。 

var array = [[12, 45, 75], [54, 45, 2], [23, 54, 75, 2]],
    min = array.reduce(function min(a, b) {
        return Math.min(Array.isArray(a) ? a.reduce(min) : a, Array.isArray(b) ? b.reduce(min) : b);
    }),
    max = array.reduce(function max(a, b) {
        return Math.max(Array.isArray(a) ? a.reduce(max) : a, Array.isArray(b) ? b.reduce(max) : b);
    });
    
console.log(min, max);

具有用作回调的函数。

function flat(f, v) { return Array.isArray(v) ? v.reduce(f) : v; }
function getMin(a, b) { return Math.min(flat(getMin, a), flat(getMin, b)); }
function getMax(a, b) { return Math.max(flat(getMax, a), flat(getMax, b)); }

var array = [[12, 45, 75], [54, 45, 2], [23, 54, 75, 2]],
    min = array.reduce(getMin),
    max = array.reduce(getMax);
    
console.log(min, max);

1
投票

您可以简单地将所有嵌套数组合并为一个数组，然后使用 

Math.min.apply(null, array)
和 
Math.max.apply(null, array)

查找最小值和最大值 

var arr = [[12,45,75], [54,45,2],[23,54,75,2]];
var merged = [].concat.apply([], arr);
var max = Math.max.apply(null, merged);
var min = Math.min.apply(null, merged);
console.log(max,min)

0
投票

无需串联的解决方案，适用于任何级别的嵌套

let arr = [[12,45,75], [54,45,2],[23,54,75,2]];

function findMaxFromNestedArray(arr) {
  let max = Number.MIN_SAFE_INTEGER;
  
  for (let item of arr) {
    if(Array.isArray(item)) {
      let maxInChildArray = findMaxFromNestedArray(item);
      if (maxInChildArray > max) {
        max = maxInChildArray;
      }
    } else {
      if (item > max) {
        max = item;
      }
    }
  }
  
  return max;
}

console.log(findMaxFromNestedArray(arr))

0
投票

只有一个reduce的解决方案：

const getMaxMin = (flattened) => {
return flattened.reduce(
        (a, b) => {            
            return {
                maxVal: Math.max(b, a.maxVal),
                minVal: Math.min(b, a.minVal),                
            };
        },
        {
            maxVal: -Infinity,
            minVal: Infinity,            
        }
    );
}
const flatSingle = arr => [].concat(...arr)
const maxMin = getMaxMin(flatSingle(arr))
console.log(maxMin);
0
投票

我们可以用 

Array.prototype.flat
展平数组。 https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat

const nestedArray = [[12,45,75], [54,45,2],[23,54,75,2]]
const flattenedArray = nestedArray.flat(2)

const minValue = Math.min.apply(null, flattenedArray)
const maxValue = Math.max.apply(null, flattenedArray)

console.log( {flattenedArray, minValue, maxValue} )

0
投票

const getFlatArr = (arr) => arr.join().split(',').map(Number)

const getMax = (arr) => {
  const newArr = getFlatArr(arr)
  let max = newArr[0]
  newArr.forEach((value) => {
    max = value > max ? value : max
  })
  return max
}

const getMin = (arr) => {
  const newArr = getFlatArr(arr)
  let min = newArr[0]
  newArr.forEach((value) => {
    min = value < min ? value : min
  })
  return min
}

const arr1 = [
  [12, 45, 75],
  [54, 45, 2],
  [23, 54, 75, 2],
]
console.log(`Max: ${getMax(arr1)}`)
console.log(`Min: ${getMin(arr1)}`)

const arr2 = [1, 2, [14, 56, 34, [48, 98]], [14, 16, 11, [18, 81]], 34, 35]
console.log(`Max: ${getMax(arr2)}`)
console.log(`Min: ${getMin(arr2)}`)

0
投票

我只是用 3 种简单的方法来更新它：

假设你有一个嵌套数组：

let numbers = [12, 44, [33, 94, 10444], 104]

您的第一步是展平阵列。有很多方法可以做到这一点，但具体来说有两种最简单的方法：

const flat = numbers.flat() // 12, 44, 33, 94, 10444, 104 

const flat = [].concat(...numbers) // 12, 44, 33, 94, 10444, 104

接下来是简单的部分 - 确定展平数组的最小值/最大值：

const min = Math.min(...flat) // 12
const max = Math.max(...flat) // 10444

或者，您可以对展平数组进行排序并获取第一个和最后一个元素：

flat.sort((a,b) => {return a-b}) // 12, 33, 44, 94, 104, 10444
const min = flat.shift() // 12
const max = flat.pop() // 104444
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.