标签: tree-traversal

我需要在Depth-first和Breadth-first Traversal顺序中对任意树进行树遍历算法.棘手的部分是我需要能够从任意节点开始并继续直到遍历另一个特定节点.

现在,我可以使用任何普通的算法并忽略遍历的节点,直到我点击起始节点并继续直到结束节点(我现在这样做),但这是丑陋和低效的.

请给我任何建议.

更新:我的每个节点都有一个与之关联的id.在某些情况下,我有开始和结束节点引用.在其他情况下,我有两个ID,我通过检查它们的ID来检查给定节点是起始节点还是结束节点.我使用深度优先遍历来查找起始节点.开始和结束节点都可以位于层次结构中的任何位置.我希望有人可以提出一个想法,我已经给出了对起始节点和终端节点的引用.顺便说一下,树中的节点实际上是按照排序顺序排序的,排序顺序从节点的每个子节点的0开始,并且有一个根节点

我需要以深度优先的方式遍历树结构的帮助.我无法想出一个算法来正确地做到这一点.

我的意见是这样的:

[
    ["A", "B", "C"],
    ["1", "2"],
    ["a", "b", "c", "d"]
]

输出应采取以下形式:

[
    "A/1/a", "A/1/b", "A/1/c", "A/1/d",
    "A/2/a", "A/2/b", "A/2/c", "A/2/d",
    "B/1/a", "B/1/b", "B/1/c", "B/1/d",
    "B/2/a", "B/2/b", "B/2/c", "B/2/d",
    "C/1/a", "C/1/b", "C/1/c", "C/1/d",
    "C/2/a", "C/2/b", "C/2/c", "C/2/d"
]

编辑3:好的,所以我让我的代码工作,但如果我使用16个节点并且搜索深度大于11,我将面临巨大的内存消耗问题.

一个soemone检查代码并告诉我如何纠正内存泄漏？

这是完整的代码:

public void searchTSP(
    int depth,
    RouterPoint startpoint,
    bool isRound,
    IRouter<RouterPoint> router)
{
  #region TSP_startpointCheck
  if (!routepoints[0].Location.Equals(startpoint.Location))
  {
    int index = Array
      .FindIndex(routepoints, x => x.Location == startpoint.Location);

    if (index != -1 && index != 0) //it's somewhere in the array
    {
      RouterPoint temprp = routepoints[0];
      routepoints[0] = routepoints[index]; //put it to index 0
      routepoints[index] = temprp;
    }
    else //it's not in the array
    {
      //we add it...
      RouterPoint[] ta = new RouterPoint[routepoints.Length + 1];
      routepoints.CopyTo(ta, 0);
      ta[routepoints.Length] …

问题:考虑一个具有l级的完整k-ary树,其节点在广度优先遍历中按其等级标记.按照深度优先遍历中遍历的顺序计算标签列表.

例如,对于具有3个级别的二叉树,所需列表为:[0 1 3 7 8 4 9 10 2 5 11 12 6 13 14]

实现此目的的一种方法是实际构建树结构并遍历它两次; 第一次遍历是广度优先,标记节点0,1,2,..当你去.第二次遍历是深度优先,报告标签0,1,3,7,..当你去.

我对避免在内存中构建树的方法感兴趣.我意识到这种树的大小与输出的大小相当,但我希望解决方案允许"流"输出(即不需要完全存储在内存中).

我也对伴侣问题感兴趣; 从根据深度优先遍历标记的树开始,并生成广度优先遍历的标签.我想在某种意义上,这个问题的解决方案将是第一个问题的双重解决方案.

如何递归删除与给定模式匹配的所有键？

我有以下jq配置，但它似乎不起作用：

walk( if (type == "object" and (.[] | test('.*'))) then del(.) else . end)

任何人都可以给我一个解决方案,以便在没有递归和不使用堆栈的情况下遍历二进制树的顺序？

我正在写一个广度深度优先树遍历功能,就是我想要做的是这样的:

def traverse(node):
    yield node
    for n in node.children:
        yield_all traverse(n) # << if Python had a yield_all statement

这个想法最终得到了树中的(平面)节点序列.

方法#1 :(传播产量)

def traverse(node):
    yield node
    for n in node.children:
        for m in traverse(n):
            yield m

方法#2 :(展平序列)

def traverse(node):
    return itertools.chain([node],*(traverse(n) for n in node.children))

第一种方法看起来更干净,但我觉得yield在每个级别的子树中明确指出每个节点都很奇怪.

第二种方法是简洁而略显肮脏,但它与我在Haskell中编写的内容相匹配:

traverse node = node : concatMap traverse (children node)

所以我的问题是:哪个更好？或者我错过了最好的第三选择？

我遇到了一个有趣的问题:

给定二进制树以向内螺旋顺序打印它,即第一打印级别1,然后是级别n,然后是级别2,然后是n-1,依此类推.

For Ex:
1
2 3
4 5 6 7
8 9 10 11 12 13 14 15

Should Output:
1 15 14 13 12 11 10 9 8 2 3 7 6 5 4

我想到了一个解决方案:

• 将每个级别元素存储在列表
  列表中[0] = [1]
  列表[1] = [2,3]
  列表[2] = [4,5,6,7]
  列表[3] = [8,9,10 ,11,12,13,14,15]

• 按所需顺序(0,n-1,1,n-2,...)循环列表列表并打印.以下n是在上述情况下为4的级别数.

它的空间复杂度为O(n).我相信可能有一个更好的解决方案,它有更好的空间复杂性,但我想不出它.任何人有任何指针？

虽然已经问过这个问题，但我有一个具体的实施问题。

我正在尝试打印二叉树的顶视图，以下是它的完整代码：

import java.util.*;

class Node{
    int data;
    Node right;
    Node left;
    Node(int data){
        this.data = data;
    }
}

class Pair<F,S>{
    private F first;
    private S second;
    public Pair(F first, S second){
        this.first = first;
        this.second = second;
    }
    
    public F getFirst(){return first;}
    public S getSecond(){return second;}
}

class BinaryTreeTopView{

    public static void printTopView(Node root){

        if(root == null)
            return;

    Queue <Pair<Node,Integer>> q = new Queue<>();
    Map <Integer,Node> map = new HashMap<>();
    Pair<Node,Integer> p = new Pair<>(root, 0);
    q.add(p);
    
    /*
    I …

我想知道是否有一种方法可以仅使用 vanilla JS 来选择 DOM 上的特定元素，而不必parentNode多次使用。我知道你可以用 jQuery 和修改来做到这一点Element.prototype，但还有其他漂亮的方法来写这个。

  const deleteButtons = document.querySelectorAll('.delete-button');

  for (var i = 0; i < deleteButtons.length; i++) {
    deleteButtons[i].addEventListener('click', (e) => {
      e.preventDefault();

      //This is the crazy amount of parentNode usage
      bookDatabase.child(e.target.parentNode.parentNode.parentNode.parentNode.parentNode.parentNode.getAttribute("id")).remove();
      });
    }