标签: tree-traversal

我必须遗漏一些非常重要的东西,我一直在使用.parent().parent().parent().. etc来遍历DOM和.next().next()来遍历DOM.

我知道这是错误的,我需要更可靠的东西,我需要一个选择器,它将从点击的元素$(this)遍历DOM,看看点击的元素是否在一个"last"类的元素中.

div.last > div > table > tr > td > a[THE ITEM CLICKED is in the element last]

和

div > div > table > tr > td > a[THE ITEM CLICKED is not in the element last]

然后如果结果有长度

var isWithinLastRow = [amazingSelector].length;

在这种情况下做其他事情.

我想在Java8节点流中转换树

这是存储可以选择的数据的节点树

public class SelectTree<D> {

  private D data;

  private boolean selected = false;

  private SelectTree<D> parent;

  private final List<SelectTree<D>> children = new ArrayList<>();

  public SelectTree(D data, SelectTree<D> parent) {
    this.data = data;
    if (parent != null) {
      this.parent = parent;
      this.parent.getChildren().add(this);
    }
  }

  public D getData() {
    return data;
  }

  public void setData(D data) {
    this.data = data;
  }

  public boolean isSelected() {
    return selected;
  }

  public void setSelected(boolean selected) {
    this.selected = selected;
  }

  public SelectTree<D> getParent() { …

我很难进行树遍历,因此就像瘟疫一样避免它...通常.

我有一个类(这里略微简化版本,但在功能上相同),如:

class Branch(object):
    def __init__(self, title, parent=None):
        self.title = title
        self.parent = parent

我有一堆Branch实例的字典,每个实例的标题作为键:

tree = {'Foo Branch': foo, 'Sub-Foo Branch': sub_foo, 'Bar Branch': bar}

现在,我知道有一些复杂的算法可以实现遍历效率(例如MPTT等),尤其适用于效率最重要的数据库驱动项目.我根本不使用数据库,只使用简单的内存中对象.

考虑到titlea Branch,我需要得到list该分支的所有后代(儿童,孩子的孩子,等等)tree,所以:

1. 你是否仍然建议在我的情况下使用像MPTT这样的复杂(对于我的算法)算法来提高效率,或者是否有一种简单的方法可以在单个函数中实现这一点？
2. 如果是这样,你会推荐哪一个,知道我没有使用数据库？
3. 你能提供一个例子,还是比我想的要大得多？

注意:这不是家庭作业.我不在学校.算法真的很糟糕.我已经将Django MPTT用于需要DB存储树的项目......但仍然不太了解它.

我正在阅读的一本书声称,检查二叉树是否是二叉树B的子树的一种方法A是构建两个树的inorder和preorder字符串(表示每棵树的顺序和前序遍历的字符串),并检查是否inorder_B是的子inorder_A 和 preorder_B是的子串preorder_A.请注意,它声称,你必须检查串匹配两者中序和序字符串.

是不是真的有必要检查一个串匹配两者中序和序字符串？检查两者都不够吗？有人可以提供一个证明我错的例子(即证明书中的权利要求)吗？我无法想出一个例子,其中两棵树是不相等的,但预订或顺序字符串匹配.

我正在寻找一种方法来建模一个树,每个节点有一个任意数量的子节点.

这个答案建议使用Boost Graph Library来完成这项任务:

什么是一个好的和稳定的C++树实现？

我需要执行的主要操作是树的遍历函数(preorder,children,leafs)及其子树.我还需要从孩子们那里收集数据的功能.

BGL是否是正确的选择,如何实现一个简单树的前序遍历？在文档中,我只能找到常规图表的信息.

编辑:我也知道tree.hh图书馆,但它的许可似乎并不适合所有人.

任何人都可以指出我在伪代码中进行迭代深度优先树遍历,在这种情况下,可以在订单前后对每个节点执行操作吗？

也就是说,在进入节点的孩子之前的行动,然后是从孩子们上升后的行动？

此外,我的树不是二进制 - 每个节点有0..n个孩子.

基本上,我的情况是转换递归遍历,我在当前节点上执行前后操作,在递归到子节点的任一侧.

我使用图形数据库 Neo4J 建模了一个有向树结构。所以我有这样的东西：http : //ouwarovite.net/YAPC/220px-Binary_tree.svg.png（非强制性二进制）

我的数据库的用户可以随意添加现有节点的子节点，所以树的高度和单个节点的度数是未知的。

现在，我想这样查询我的树：从节点 x 开始，给我所有叶子 x 的后代。

这种查询是否可以使用 Gremlin 或 Cypher 执行，如果可以，如何做到这一点以获得最大的性能？（我还没有找到对“通用”树执行查询的可能性，因为您总是必须指定最大深度）

我知道，使用 REST/JSON 框架和 JAVA API 是可能的：

POST /db/data/node/51/traverse/node 
{ 
"return_filter" : 
    {
    "body" : "position.endNode().hasProperty('leave')" ,
    "language" : "javascript" 
     }, 
"relationships" : [ { "type" : "_default", "direction" : "out" } ] , 
"prune_evaluator" : { "name" : "none" , "language" : "builtin" }
}

（我的叶子有属性“离开”，我的边缘没有类型 -> 所以 _default）

有没有更简单/更好的方法来做到这一点，也许具有更好的性能？

使用递归进行 DFS 很容易：

function dfs(tree, fn, level) {
  fn(tree, level)
  tree.children.forEach(function(child){
    dfs(child, fn, level + 1)
  })
}

然而，我见过的 BFS 的每个例子都使用队列，并且是迭代的而不是递归的。想知道是否有任何方法可以定义递归 BFS 算法。

对于二叉树，广度优先搜索遍历（BFS）是否与预序遍历相同？我对这两种不同类型的遍历有点困惑。任何人都可以向我解释一下吗？此外，预序遍历与深度优先搜索遍历(DFS) 相比如何？

非常感谢！

您好，我制作了一个简单的二叉树并添加了前序遍历方法。在提出一些想法之后，我陷入了寻找一种从traverse_pre()数组中的方法返回每个值的方法上。

class BST:
    def __init__(self, val):
        self.value = val
        self.left = None
        self.right = None

    def add_child(self, val):
        if self.value:
            if val < self.value:
                if self.left == None:
                    self.left = BST(val)
                else:
                    self.left.add_child(val)
            else:
                if val > self.value:
                    if self.right == None:
                        self.right = BST(val)
                    else:
                        self.right.add_child(val)
        else:
            self.value = val

    def traverse_pre(self):
        if self.left:
            self.left.traverse_pre()
        print(self.value)

        if self.right:
            self.right.traverse_pre()


Tree = BST(5)
Tree.add_child(10)
Tree.add_child(8)
Tree.add_child(2)
Tree.add_child(4)
Tree.add_child(7)

Tree.traverse_pre()

我将如何修改该traverse_pre()函数以返回由节点值组成的数组。有没有这个过程的一个很好的例子让我进一步理解这一点，我有点困惑如何在递归中将值附加到数组中。