后序遍历纯javascript

Question

我想在一项任务中寻求帮助，我必须穿过一棵树并得到它：

 [ 4, 2, 5, 7, 6, 3, 1 ]

班级：

class Traversal {
  postOrderTraversal(tree) {
    // ...code here
  }
}

我的对象：

const tree = {
  value: 1,
  children: [
    {
      value: 2,
      children: [
        { 
          value: 4,
          children: [] 
        }
      ],
    },
    {
      value: 3,
      children: [
        {
          value: 5,
          children: [],
        },
        {
          value: 6,
          children: [
            {
              value: 7,
              children: [],
            },
          ],
        },
      ],
    },
  ],
};

示例说明（每个节点最多有两个子节点）：

                          +----------------+
                          |     value:   1 |
                          +----------------+
                            /            \
                           /              \
            +----------------+        +----------------+
            |     value:   2 |        |     value:   3 |
            +----------------+        +----------------+
               /                         /           \
              /                         /             \
 +----------------+       +----------------+       +----------------+
 |     value:   4 |       |     value:   5 |       |     value:   6 |
 +----------------+       +----------------+       +----------------+
                                                        /
                                                       /
                                         +----------------+
                                         |     value:   7 |
                                         +----------------+

如果有人可以提供帮助，请使用纯 JavaScript，以便我更好地理解它。

Answer 1

我认为使用递归很好地展示了 post order 是如何工作的。我发现这是一个相对简单的解决方案。

class Traversal {
    postOrderTraversal(tree, arr=[]) {
        if(tree) {
            this.postOrderTraversal(tree.children[0], arr);
            this.postOrderTraversal(tree.children[1], arr);
            arr.push(tree.value);
        }

        return arr;
    }
}

由于您的数据集是一棵树，我假设children[0] 被认为是左节点，children[1] 被认为是右节点。

Answer 2

这可能是我能想到的最简单的实现。只给了两行代码，解释的余地​​很小-

function *postorder(t) {
  for (child of t.children) yield *postorder(child)
  yield t.value
}

const mytree = {value:1,children:[{value:2,children:[{value:4,children:[]}]},{value:3,children:[{value:5,children:[]},{value:6,children:[{value:7,children:[]}]}]}]}

console.log(Array.from(postorder(mytree)))

[4,2,5,7,6,3,1]

虽然可以使用类来混淆遍历，但对您没有任何好处。 postorder 保持不变 -

function *postorder(t) {
  for (child of t.children) yield *postorder(child)
  yield t.value
}

class Traversal {
  postorder(t) { return Array.from(postorder(t)) }
}

const mytree = {value:1,children:[{value:2,children:[{value:4,children:[]}]},{value:3,children:[{value:5,children:[]},{value:6,children:[{value:7,children:[]}]}]}]}

const q = new Traversal()

console.log(q.postorder(mytree))

与preorder 比较。实现这种遍历唯一需要的改变就是切换两行的顺序-

function *preorder(t) {
  yield t.value
  for (child of t.children) yield *preorder(child)
}

const mytree = {value:1,children:[{value:2,children:[{value:4,children:[]}]},{value:3,children:[{value:5,children:[]},{value:6,children:[{value:7,children:[]}]}]}]}

console.log(Array.from(preorder(mytree)))

[1,2,4,3,5,6,7]

Answer 3

与这类树访问算法的常见情况一样，最好的选择在于递归：树中的每个节点都应该在其子节点的值之后返回自己的值。肯定有比我在下面写的更短和更有效的方法来做到这一点，但是我已经以这样一种方式构造了代码，使得递归终止（当前节点没有子节点）以及值的顺序很清楚被添加到返回的数组中以便于理解。

function postOrderTraversal(node) {
  if (node.children.length === 0) {
    return [node.value];
  } else {
    var arr = [];
    for (var i = 0; i < node.children.length; i++) {
      var childValues = postOrderTraversal(node.children[i]);
      arr = arr.concat(childValues);
    }
    arr.push(node.value);
    return arr;
  }
}