我正在尝试使用递归来在JavaScript中查找数组中的最大值。我创建了该函数，但无法弄清楚如何递归执行。
function Max(a) {
var a = [2,3,5];
return Math.max.apply(Math, a);
}
答案 0 :(得分：1)
这是一个递归函数的示例，它接受一个数字数组并比较前两个，删除较小的数字，然后在给定数组上再次调用自身减去删除的数字。
function max(numArray)
{
// copy the given array
nums = numArray.slice();
// base case: if we're at the last number, return it
if (nums.length == 1) { return nums[0]; }
// check the first two numbers in the array and remove the lesser
if (nums[0] < nums[1]) { nums.splice(0,1); }
else { nums.splice(1,1); }
// with one less number in the array, call the same function
return max(nums);
}
这是一个jsfiddle：https://jsfiddle.net/t3q5sm1g/1/
答案 1 :(得分：0)
NO ACTION每次调用递归的情况时，它都会更接近基本情况。
Math.max接受两个数字，然后比较它们，然后从两个数字中返回更高的数字。
每次调用array.shift（）时，都会从数组中弹出数组中的第一个元素，因此递归调用中的第二个参数是缩短为1的数组。
当array.length只有一个元素时，返回该元素并观察堆栈展开。
答案 2 :(得分：0)
这实际上是我向候选人询问软件位置的问题之一：找到锯齿状阵列中的最大数量。数组的每个元素可以是无限数量级别的数字或其他数字的数组，如下所示：
var ar = [2, 4, 10, [12, 4, [100, 99], 4], [3, 2, 99], 0];
现在，只是为了好玩并保持这篇文章的简短，我将在这个问题中加入两个解决方案。第一种解决方案使用递归，而第二种解决方案使用堆栈。事实上，所有这些递归问题也可以通过使用堆栈方法来解决。
// Use recursion to find the maximum numeric value in an array of arrays
function findMax1(ar)
{
var max = -Infinity;
// Cycle through all the elements of the array
for(var i = 0; i < ar.length; i++)
{
var el = ar[i];
// If an element is of type array then invoke the same function
// to find out the maximum element of that subarray
if ( Array.isArray(el) )
{
el = findMax1( el );
}
if ( el > max )
{
max = el;
}
}
return max;
}
// Use a stack to find the maximum numeric value in an array of arrays
function findMax2(arElements)
{
var max = -Infinity;
// This is the stack on which will put the first array and then
// all the other sub-arrays that we find as we traverse an array
var arrays = [];
arrays.push(arElements);
// Loop as long as are arrays added to the stack for processing
while(arrays.length > 0)
{
// Extract an array from the stack
ar = arrays.pop();
// ... and loop through its elements
for(var i = 0; i < ar.length; i++)
{
var el = ar[i];
// If an element is of type array, we'll add it to stack
// to be processed later
if ( Array.isArray(el) )
{
arrays.push(el);
continue;
}
if ( el > max )
{
max = el;
}
}
}
return max;
}
随意优化上述代码。您还可以将此代码视为gist on github。
答案 3 :(得分：0)
let max = (list) => {
// Returns first number if list length is 1
if (list.length === 1) return list[0]
// Returns the greater number between the first 2 numbers in an array
if (list.length === 2) return (list[0] > list[1]) ? list[0] : list[1]
// If array length is 3+ (Read Below)
const subMax = max(list.slice(1));
return (list[0] > subMax) ? list[0] : subMax;
}
// Example
max([5,5,5,8,6,7,4,7])
了解递归的“调用堆栈”的工作原理很重要。
在上面的示例中，由于数组长度超过3，因此要调用的第一行是
const subMax = max(list.slice(1));
此行所做的只是取出数组中的第一项，并调用以较短数组为参数的函数。这一直持续到数组长度为2，然后返回2中的较大者为止。然后，该函数可以完成其之前所有部分完成的状态。
答案 4 :(得分：0)
ES6语法使这一点非常简洁。
const findMax = arr => {
if (!Array.isArray(arr)) throw 'Not an array'
if (arr.length === 0) return undefined
const [head, ...tail] = arr
if (arr.length === 1) return head
return head > findMax(tail)
? head
: findMax(tail)
}
答案 5 :(得分：0)
尝试一下：
const biggestElement = list => {
if (list.length == 1)
return list[0];
if (list[0] > list[1])
list[1] = list[0];
list = list.splice(1);
return biggestElement(list);
}
答案 6 :(得分：0)
function recursiveMaxNumber(items){
if(items.length === 1){
return items[0] //Base-case reached
}
else{
if(items[0]>=items[items.length-1]){
items.pop() //remove the last item in the array
return recursiveMaxNumber(items)
}
else{
return recursiveMaxNumber(items.slice(1)) //remove the first item in the array
}
}
}
console.log(recursiveMaxNumber([2,22,3,3,4,44,33]))
答案 7 :(得分：0)
虽然下面是我的尝试不是一种有效的方法，
function max(a, b) {
return a > b ? a : b
}
function findMaxOfArrayRecursion(arr) {
if (arr.length == 1) {
return arr[0]
}
return max(arr[0], findMaxOfArrayRecursion(arr.slice(1)))
}
基本上我们假设第一个数组元素是最大值并以递归方式将其与其他元素进行比较。
添加一个高效的非递归方法，仅供参考，
Math.max(...arr)