好的,这有点棘手。
我有一堆代码采用表达式树:
((a + b)/(c + d) + sqrt(e))
以前缀形式存储在向量中(我使用的是C ++,但我只需要算法):
+(/(+(a,b),+(c,d)),sqrt(e))
//括号只是为了帮助您阅读它。每个运算符和终端都是向量中的元素。
现在有另外一种表示表达树的方法,称为ORF形式
(论文的第三页:http://arxiv.org/ftp/cs/papers/0102/0102027.pdf)
在此表单中,您表示树,就像从左到右,从上到下阅读树。
((a + b)/(c + d) + sqrt(e))
现在变为:
+/sqrt++eabcd
我一直没做的是创建一个可以转换的算法:
+/sqrt++eabcd
// ORF
成:
+(/(+(a,b),+(c,d)),sqrt(e))
//前缀
到目前为止,我所拥有的是一些代码,可以在不同的层次上获得树的广度:
bool ConvertPrefixToORF(const std::vector<Node> & individual,
std::vector<Node> & ETindividual){
bool all_terminal = false;
int breadth;
int breadthOfDepth[individual.size()];
int depthCounter = 0;
breadthOfDepth[0] = 1;
//Resize only once.
ETindividual.reserve(individual.size());
while (all_terminal == false) {
//Reset breadth
breadth = 0;
//Iterate over next level and calculate depth of level after that.
for (int i = 0; i < breadthOfDepth[depthCounter]; i++) {
all_terminal = true;
//If the individual is a function...
if (individual[current+i].isFunction()) {
//Get individual from i'th item at this depth
function f = individual[current + i];
//Increment breadth of next level with arity
breadth += f->getArity();
//if a single function is found
all_terminal = false;
}
}
//Go down a level in the tree.
depthCounter++;
//Set the breadth of that tree depth:
breadthOfDepth[depthCounter] = breadth;
}
}
提前感谢您的帮助!这是我的头脑。哦,这对性能至关重要:(
答案 0 :(得分:2)
我的策略是构建解析树,然后在深度优先处理它以生成前缀表示法。
您可以使用队列从ORF构建解析树。当您遇到每个运算符(或术语)时,请将其作为队列头部的运算符的子项。当队列头部的节点有足够的子节点时,将其从队列中弹出。
在你的例子中......从+
开始并将其推入队列(初始元素的特殊情况)。
接下来处理/
。由于队列头部的+
没有子项(但需要两个),因此您将/
作为第一个孩子附加到+
并将/
推到队列。所以现在队列看起来像:
+/
......树看起来像
+
/ .
. .
......其中“。”是一个等待填补的元素。
接下来是sqrt
。由于+
位于队列的头部并且还没有两个孩子,因此请将sqrt
附加到+
并将sqrt
推送到队列中。所以现在队列看起来像:
+/sqrt
......树看起来像
+
/ sqrt
. . .
接下来是第二个+
。队列的头部是第一个+
,但现在已经有了它的所有孩子。所以把它从队列中弹出。队列的下一个元素是/
,它还没有子节点,所以这个+
成为它的子节点并进入队列的后面。队列现在写着:
/sqrt+
...现在是树:
+
/ sqrt
+ . .
. .
接下来,第三个+
成为/
的第二个子项,并被推入队列。所以队列将是:
/sqrt++
...树将会(抱歉,我的ASCII艺术很弱):
+
/ sqrt
+ + .
. . . .
现在/
已满足,因此当您点击e
时,会从队列中弹出/
。现在sqrt
是队列的开头,因此e
附加到该队列。队列现在是:
sqrt++
...而树是:
+
/ sqrt
+ + e
. . . .
接下来的四次迭代显然将a,b,c,d分配给剩余的叶子,为你提供解析树。
顺便说一句, std::dequeue
是一个完美的数据结构,用于队列。
答案 1 :(得分:0)
只需构建一个树T.每个节点都是一个元组(terminal,)
或(unary_operator, operand)
或(binary_operator, first_operand, second_operand)
。操作数本身是树中节点的索引。
例如,表达式a + (b / c)
将具有树T[0] = (+, 1, 2), T[1] = (a,), T[2] = (/, 3, 4), T[3] = (b,), T[4] = (c,)
。一旦你有这个只是做一个预购。这是Python的代码。
def preorder(T, i):
X = [T[i][0]]
if len(T[i]) > 1:
X.extend(preorder(T, T[i][1]))
if len(T[i]) > 2:
X.extend(preorder(T, T[i][2]))
return X
def convert(A):
binary_operators = ['+', '-', '/']
unary_operators = ['sqrt']
left = 0
right = 0
T = dict([(i, ()) for i in range(len(A))])
for a in A:
if a in binary_operators:
T[left] = (a, right + 1, right + 2)
right += 2
elif a in unary_operators:
T[left] = (a, right + 1)
right += 1
else:
T[left] = (a,)
left += 1
return preorder(T, 0)
def main(argv=None):
A = ['+', '/', 'sqrt', '+', '+', 'e', 'a', 'b', 'c', 'd']
print convert(A)
当你从你的ORF中构建T时,保留一个左右指针,告诉你必须在表达式树中填写第一个节点,然后右边告诉你最后一个节点。