Question

我申请了一项工作，我接受了这项任务。我不得不编写一个函数reversePrint()，它返回一个反转数组，其中包含来自传递对象的值。

这是对象

var someList = {
    value: 1,
    next: {
        value: 2,
        next: {
            value: 3,
            next: {
                value: 4,
                next: null
            }
        }
    }
};

我的尝试

function reversePrint(linkedList) {
  // empty array with the result
  var b = [];
  // while loop to check if current next is not null
  while ( linkedList.next !== null ) {
    // push current value into the array
    b.push(linkedList.value);
    // go one level deeper
    linkedList = linkedList.next;
  }
  // push the last value into the array
  b.push(linkedList.value);
  // return reversed array
  return b.reverse();
}

该功能有效，但我觉得有更好的方法可以做到这一点。我已经搜索了stackoverflow的javascript递归操作，但是找不到任何被认为是重复的东西。有没有更有效的方法来做到这一点？

Answer 1

您的代码没有根本错误，但您的直觉是正确的：递归解决方案似乎更好地匹配数据结构的递归性质，更简洁，也可以编写以避免相反。

＆＃13;

var someList = {value: 1, next: {
    value: 2, next: {
        value: 3, next: {
            value: 4, next: null}}}};

function reversePrint(input) {
  return !input ? [] : reversePrint(input.next).concat(input.value); 
}

console.log(reversePrint(someList));

＆＃13;

请注意，此解决方案不能进行尾部优化，如果输入可能非常深，则最好避免使用此解决方案。可以尾部优化的解决方案是：

function reversePrint(input) {
  return function inner(input) {
    return !input ? [] : [input.value].concat(inner(input.next));
  }(input).reverse();
}

当然，可以避免使用迭代解决方案进行反向，但是在每一步都要求在阵列的正面进行昂贵的非移位操作。另一方面，递归解决方案创建了多个逐渐增加长度的数组，这也不是很便宜。

Answer 2

https://jsfiddle.net/zwzecvqf/2/

这里有一个递归函数。

function reversePrint (item) {
  var nextItem = item.next
  var items

  if (nextItem) {
        items = reversePrint(nextItem)
  } else {
        items = [];
  }  

  items.push(item.value)
  return  items
}

Answer 3

使用递归你也可以这样做。

＆＃13;

import wx.lib.colourdb as wb
col_str = 'South Shore Lily Rose 4 Drawer Chest in White Wash'
colr = wb.getColourList()
for x in col_str.split(" "):
    if(x.upper() in colr):
        print(x)

＆＃13;

Answer 4

又一种递归解决方案，但避免创建和丢弃多个中间数组：

function reversePrint(node, array) {
  // Fill in the array if not given
  array = array || [];
  // Recurse if appropriate
  if (node.next) {
    reversePrint(node.next, array);
  }
  // Add the value on the way out
  array.push(node.value);
  return array;
}

function reversePrint(node, array) {
  array = array || [];
  if (node.next) {
    reversePrint(node.next, array);
  }
  array.push(node.value);
  return array;
}
var someList = {
    value: 1,
    next: {
        value: 2,
        next: {
            value: 3,
            next: {
                value: 4,
                next: null
            }
        }
    }
};
console.log(reversePrint(someList));

Answer 5

不使用递归怎么样？我没有找到这个没有被禁止的信息。

var someList = {
    value: 1,
    next: {
        value: 2,
        next: {
            value: 3,
            next: {
                value: 4,
                next: null
            }
        }
    }
};

function reversePrint()
{
    var currentNode = someList;
    var cacheList = [];
    do
    {
        cacheList.push(currentNode.value);
        currentNode = currentNode.next;
    }
    while(currentNode != null);

    cacheList.reverse();  
    return cacheList;
}

var reverseList = reversePrint(); // [4,3,2,1]

Answer 6

这里使用递归函数对子对象值

function reversePrint(linkedList) {
  // empty array with the result
  var b = [];

  function addValues(subList){
     if(linkedList.next)
        addValues(linkedList.next);

    b.push(item.value);
  }

  addValues(linkedList);
  return b.revers();  
}

Javascript递归计数

6 个答案: