Question

创建一个函数traverse，其中第一个args为树，第二个为empty_fn()，leaf_fn(arg)，第三个为node_fn(arg0,arg1,arg2) } 如果树为空，则应调用带有0个args的函数empty_fn()。因此，如果我们遇到一个叶子，则应运行leaf_fn(arg)，如果我们有一个子树，则应运行函数node_fn(arg0,arg1,arg2)。
创建调用contains_key的函数traverse()，并检查给定二叉树中是否存在密钥。此函数主要用于创建traverse用作参数的三个函数。
创建一个新函数tree_size()，它调用traverse()函数并返回树的大小。

注意：树不一定要以正确的方式排序，例如[[3,5,4],1,0]是有效的树

示例

def empty_fn():
    return 0


def leaf_fn(key):
    return key**2


def node_fn(key, left_value, right_value): 
    return key + left_value
>>> traverse([6, 7, 8], inner_node_fn, leaf_fn, empty_tree_fn)
43

这里是我尝试解决问题，给出了规范中运行的程序示例：

def traverse(tree,empty_tree_fn,leaf_fn, inner_node_fn ):
    if is_empty_tree(tree):
        return empty_tree_fn()
    else:
        if is_leaf(tree[0]):
            tree[0]=leaf_fn(tree[0])

        elif is_leaf(tree[2]):
            tree[2]=leaf_fn(tree[2])
        return inner_node_fn(tree[1],tree[0],tree[2])

如果我针对示例给出的输入运行它，我得到相同的输出，这意味着这是正确的方法吗？一旦我们跳到问题的第二部分，它会变得更复杂，因为我要创建一个新版本的traverse() namley traverse2_0以满足问题1的要求。这是我的代码：

def traverse2_0(tree,empty_tree_fn,leaf_fn, inner_node_fn ):
    if is_empty_tree(tree):
        return empty_tree_fn()
    else:
        """if is_leaf(tree[0]) and is_leaf(tree[2]):
            return leaf_fn(tree[0]) or leaf_fn(tree[2])""" #lazy mechanism
        if is_leaf(tree[0]):
            if leaf_fn(tree[0]):
                return True
        if is_leaf(tree[2]):
            if leaf_fn(tree[2]):
                return True
        else:
            return inner_node_fn(tree[1],tree[0],tree[2])
    return False
def contains_key(key, tree):
    #print (tree)
    def empty_fn(tree):
        return not is_empty_tree(tree)
    def leaf_fn(side):
        return side==key
    def inner_node_fn(k,left,right):
        if  isinstance(left,list) and isinstance(right,list):
            return contains_key(key, left) or contains_key(key, right)
        elif  isinstance(left,list):
            return contains_key(key,left)
        elif isinstance(right,list):
            return contains_key(key, right)
    if key==tree[1]:
        return True
    else:
        return traverse2_0(tree,empty_fn,leaf_fn,inner_node_fn)

如果我想使用traverse()，那么一旦我们到达第三个就更复杂，所以我必须递归地解决它。但是，除了第一个解决方案之外，我的解决方案都不符合我的L.I.提出的问题要求。在这个例子中，我觉得没有办法满足所有三个要求。

def tree_size(tree):
    if not tree: #corresponds to empty_tree_fn
        return 0
    if isinstance(tree[0],list): #corresponds to inner_node_fn
        return tree_size(tree[0])+tree_size(tree[1:])
    else:
        return 1+tree_size(tree[1:]) #corresponds to leaf_fn
print (tree_size( [[0,1,2],2,[1,3,2]]))

这是一个很长的问题，我知道这一点，并感谢任何相关的答案。

Answer 1

retry

虽然解决方案不适用于嵌套子树，但会感激任何反馈。我打开这个问题，希望得到更多答案

未排序的二进制搜索树，遍历，大小

1 个答案: