Question

嵌套数组如下：

var arr = [{
  id: 2,
  name: 'a',
  children: []
}, {
  id: 5,
  name: 'b',
  children: [{ 
    id: 14,
    name: 'b2'
  }]

}, {
  id: 15,
  name: 'd',
  children: []
}];

如何从任何给定元素中列出祖先元素？

例如，如果给定元素具有id: 14，则列表应仅返回父级：

[{
  id: 5,
  name: 'b',
  children: [...]
}]

我正在寻找复制“面包屑”导航

Answer 1

您可以移交作为父对象的对象，然后递归搜索所需的id。

function getParent(object, id) {
    var result;
    (object.children || []).some(o => result = o.id === id ? object : getParent(o, id));
    return result;
}

var array = [{ id: 2, name: 'a', children: [] }, { id: 5, name: 'b', children: [{  id: 14, name: 'b2' }] }, { id: 15, name: 'd', children: [] }];

console.log(getParent({ children: array }, 14));

.as-console-wrapper { max-height: 100% !important; top: 0; }

如果您希望移交数组，则可以采用具有递归功能的嵌套方法。

function getParent(children, id) {

    function iter(object) {
        var result;
        (object.children || []).some(o => result = o.id === id ? object : iter(o));
        return result;
    }

    return iter({ children });
}

var array = [{ id: 2, name: 'a', children: [] }, { id: 5, name: 'b', children: [{  id: 14, name: 'b2' }] }, { id: 15, name: 'd', children: [] }];

console.log(getParent(array, 14));

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 2

如果我们可以假设仅存在两个级别（父母和子女，而不是子女的子女），则以下功能findAncestor()可以满足您的需求。迭代所有父元素，并检查它们是否有一个具有相关ID的子元素。

function findAncestor(id) {
  for (let i = 0; i < arr.length; i++) {
    let obj = arr[i];
    if (obj.hasOwnProperty('children')) {
      if (obj.children.length > 0) {
        for (let j = 0; j < obj.children.length; j++) {
          if (obj.children[j].id === id) {
            return obj;
          }
        }
      }
    }
  }

  return null;
}

console.info(findAncestor(14));

如果需要处理一个ID相同的孩子可能在多个父母中发生的情况，则应使用结果数组并将所有找到的结果添加到该数组中，然后最后将其返回。

Answer 3

您可以尝试这种方式，

        do {
        printf("Do you want to find a factorial? Y || y to continue");
        scanf("%c", &ch);
        printf("Enter the value of Number:");
        scanf("%d", &num);

//Here you do your factorial number computation and error checks

    } while (ch == 'y' || ch == 'Y');

Answer 4

深度优先搜索算法-获取父节点是：

function getParentNodeByKey(obj, targetId, paramKey) {
    if (obj.children) {
        if (obj.children.some(ch => ch[paramKey] === targetId))
            return obj;
        else {
            for (let item of obj.children) {
                let check = this.getParentNodeByKey(item, targetId, paramKey)
                if (check) {
                    return check;
                }
            }
        }
    }
    return null
}

和要测试的代码：

var arr = [{
    id: 2,
    name: 'a',
    children: []
  }, {
    id: 5,
    name: 'b',
    children: [{
      id: 14,
      name: 'b2'
    }]

  }, {
    id: 15,
    name: 'd',
    children: []
}];

let parentElement;
const valueToFind = 14;
const desiredkey = 'id';
for (let i = 0; i < arr.length; i++) {
    parentElement = getParentNodeByKey(arr[i], valueToFind, desiredkey);
    if(parentElement)
        break;
}

console.log(`The parent element is:`, parentElement);

从嵌套数组构建祖先列表

4 个答案: