未排序的二進制搜索樹，遍歷，大小

Question

1. 創建一個函數traverse ，它取4個args ，第一個是樹，第二個是empty_fn() ， leaf_fn(arg) ，第三個是node_fn(arg0,arg1,arg2)如果樹是空的函數empty_fn() ，它取0個args應該叫。 因此，如果我們遇到一個葉子，應該運行leaf_fn(arg) ，如果我們有一個子樹，則應該運行函數node_fn(arg0,arg1,arg2) 。

2. 創建函數contains_key ，該函數調用traverse()並檢查給定二叉樹中是否存在密鑰。 此函數主要用於創建traverse用作參數的三個函數。

3. 創建一個新函數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()所以我必須遞歸地解決它。 但是，除了第一個解決方案之外，我的解決方案都不符合我的LI提出的問題的要求，我覺得在給出示例的情況下無法滿足所有三個要求。

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

from tree import *
def traverse(bst,empty_fn,leaf_fn,inner_node_fn):
    if is_empty_tree(bst):
        return empty_fn()
    else:
        left,root,right= bst[0],bst[1],bst[2]
        if is_leaf(left):
            left= leaf_fn(left)
        if is_leaf(right):
            right=leaf_fn(right)
        return inner_node_fn(root,left, right)
def contains_key(key, tree):
    def empty_fn():
        return not is_empty_tree(tree)
    def leaf_fn(side):
        return side==key
    def inner_node_fn(k,left,right):
        if k==key:
            return True
        if isinstance(left,list) and isinstance(right,list):
            return contains_key(key,left) or contains_key(key,right)
        elif isinstance(right,list):
            return contains_key(key,right)
        elif isinstance (left,list):

            return contains_key(key,left)
        else:
            return right or left

    return traverse(tree,empty_fn,leaf_fn,inner_node_fn)

print(contains_key("m", [["m",6,4], 7, [[2, 3, 4], 0, []]]))

該解決方案不適用於嵌套子樹，但是會感激任何反饋。 我打開這個問題，希望得到更多答案