我想编写一个函数load: 'a option list -> 'a tree,它从给定列表中恢复二进制树,其中包含后缀顺序的元素.如果列表不代表任何树,则您的函数应该引发异常Load(您必须先声明它).
树被定义为:
type ‘a btree = L of ‘a | N of ‘a btree * ‘a btree
到目前为止,我所做的是:
exception Load ;;
let rec load l =
match l with
| [] -> raise Load
| Some x::_ -> L x
| None::t -> N(?,load t)
;;
以下是输入列表的示例:
[Some 2; Some 0; None; Some 5; Some 9; Some 20; None; None; None]
如何做到这一点真是太棘手了.由于列表是后缀顺序,我想知道是否更好地使用List.foldright函数??
我希望以最低成本遍历二叉树,其中每个边的成本为1. 当访问树的每个节点时,遍历完成.
例如,跟随树的遍历的最低成本是13.
*
/ \
* *
/ \ \
* * *
/ / \
* * *
跟随树的遍历的最低成本是12.
*
/ \
* *
/ \ \
* * *
/ \
* *
/
*
我试图了解如何使用 Traversable 迭代我的树数据结构。我有一棵丑陋的树（实际上是森林），看起来像这样：
data ParseTree a = Leaf a | Node a (ParseTree a) (ParseTree a) | MultiNode a [ParseTree a]
deriving (Show, Functor, F.Foldable, T.Traversable)
t = Node S
(Node NP (Leaf DP) (Leaf NP))
(MultiNode VP
[Node VP (Node VP (Leaf VP) (Leaf PP)) (Node NP (Leaf DP) (Leaf NP)),
Node VP (Leaf VP) (Node PP (Leaf PP) (Node NP (Leaf DP) (Leaf NP)))]
)
我想找到多节点，以便我可以替换构建新树，多节点中的每个项目一个。
对我来说编写这样的函数很容易
findmulti :: ParseTree a -> [ParseTree a]
findmulti (Leaf a) = …我目前是一名学生，他的作业涉及将二叉树方法调整为通用树方法。我唯一的问题是，我对以下通用树的后序遍历是否正确？如果是这样，那么我知道我的算法正在工作，我只是无法正确掌握后序遍历的窍门，我觉得并认为该网站可以提供帮助。
B
--------------------|------------------
| | |
A ------D----- ---I---
| | | | |
C E G H L
|
F
我的结果是：ACEFGDHLIB
简单.我想遍历DOM并找到所有具有id属性的元素.有人可以帮助我使用js和/或jquery脚本
我有一个Node类如下:
public class Node{
Object data;
List<Node> children;
}
我需要按照邮政顺序遍历这棵树,并且我使用的是Guava TreeTraverser.
TreeTraverser<Node> treeTraverser = new TreeTraverser<Node>() {
@Override
public Iterable<Node> children(Node node) {
return node.children;
}
};
treeTraverser.postOrderTraversal(node);
问题在于,给定树可能具有循环依赖性(意味着它可能是循环图).什么是检测循环依赖的有效方法？
我有一个意大利面堆栈（一种 N 元树数据结构，其中子节点具有指向父节点的指针）- 从数据库接收。
从数据库接收到的“堆栈”只是一个包含所有节点的列表，因此内部可以有多个堆栈。
节点是数据库中的记录，其中 parent.id 是到相同类型的另一条记录的外键。
class Node_Category:
def __init__(self, value):
self.value = value
parent_id = id
结构是这样的：
Category 1
-Category 1_1
--Category 1_1_1
-Category 1_2
Category_2
Category_3
-Category 3_1
-Category 3_2
我需要的：
现在我知道孩子的父母了。从父节点开始，我需要了解他的孩子。
所以我需要遍历“Spaghetti Stack”，将父节点中的连接添加到子节点，以便我可以从父节点遍历到子节点。
一个父级可以有 0 个、一个或多个子级。
因为我不知道堆栈的深度，所以我尝试递归进行。
此外，我认为某种形式的记忆是必要的，因为通过数组循环父级的父级可以获得多次访问。
我试过的：
def _recurse_for_parents(self, category, path=None):
if path is None:
path = []
path.append(category)
if category.parent:
return self._recurse_for_parents(category.parent, path)
return path
for record in categories:
self._recurse_for_parents(category)
问题：
在循环中，我可以击中父级、一级子级、二级级等：
Child1_L2-Child1_L1->parent; Child1_L1->parent; parent->Null
Child1_L1->parent; parent->Null
Child2_L1->parent; parent->Null
所以，我多次在不同的深度上走同一条路。同样对于每条路径，我需要添加从他的父母回到孩子的链接。
所以我在研究树遍历算法。例如，在 Kd 树遍历中，我们的目标是将节点向下遍历到叶子节点。这与其说是树搜索，不如说是从根到叶的遍历。
在这种情况下，递归解决方案就足够了。但是，在像 C 这样的语言中，递归调用函数需要将值压入堆栈并在堆栈帧之间跳转等。标准递归方法类似于：
void traverse(Node* ptr){
if(ptr.left == null && ptr.right == null) return;
if(ptr.val >= threshold) traverse(ptr.right);
else if(ptr.val < threshold) traverse(ptr.left);
}
traverse(root);
因此，考虑到二叉树有一个明确的上限（我相信这也可以扩展到其他树类型），以迭代方式执行此遍历是否会更有效：
Node* ptr = root;
for(int i = 0; i < tree.maxHeight; i++) {
if (ptr.left == null && ptr.right == null) break;
if (ptr.val >= threshold) ptr = ptr.right;
else if (ptr.val < threshold) ptr = ptr.left
}
二叉树的最大高度将是它的节点数，而平衡的将是 log(n)。因此，我想知道迭代解决方案是否有任何缺点，或者它是否确实比简单的递归更快。我在这方面缺少任何概念吗？
所以我需要使用递归实现成员函数,预订和按顺序遍历二叉搜索树.我无法实现所有三个,因为他们输出错误的输出.遍历应该将它遇到的数据值添加到给定的链表中.
我的成员函数只打印出树的正确节点.我附上了我的代码,如果有人可以给我一些关于错误所在的指针以及为什么输出没有打印它应该是什么的话,那将是惊人的.提前致谢!!!
我目前得到的输出:
size of test BinaryTree: 11
member true for 8
member true for 38
member true for 39
member true for 45
pre order: [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 45, 45]
in order: [8, 8, 8, 8, 38, 38, 38]
我想要的输出:
size of test BinaryTree: 11
member true for 1
member true for 3
member true for 4
member true for 7
member …我有一个python代码将字符串数学表达式转换成二叉树并排序树的节点，以便左子节点始终小于右子节点。我想按以下顺序打印二叉树。
例如，考虑数学表达式（（2 * 75）/ 4）。buildParseTree（）将字符串表达式转换为树，并且printNodeInLevels（）重新排列节点，以便在每个级别上，左子项小于右子项。操作数<运算符和运算符的顺序为'+'<'-'<'*'<'/'。如果树的结构是这样的
+
/\
4 *
/\
2 75
我想按以下方式打印它。我应该怎么做？因为数学表达式的长度一直在变化，例如（24 * 2），（（5-1）*（2/3）），（20-（5 + 4））等
Node("+") #root
.addkid(Node("*") #right child at level 1
.addkid(Node("75")) #right child at level 2
.addkid(Node("2")) #left child at level 2
)
.addkid(Node("4")) #left child at level 1
我已经设计出按顺序遍历模式按节点级别打印节点的方法，如果我按如下方式调用该方法，它将打印以下内容：
pt = buildParseTree("( ( 2 * 74 ) / 4 )")
printNodesInLevels(pt)
输出：
/
4 *
2 74