python中树、二叉树和二叉搜索树的实现差异

我很难理解简单树、二叉树和二叉搜索树在方法和实现上的差异。我似乎一直在混淆这三个问题。我知道如何实现BST。但是，我不太确定简单树和二叉树。有人能给我一个简单的树的实现/代码吗。 这不是家庭作业，是我理解这些ADT的

这是BST的代码，我有

“”“二进制搜索树ADT”“”

BST级：
def uuu init uuuu（self:'BST'，root:BTNode=None）->None:
“”“使用BTNode根目录创建BST。”“”
self.\u根=根
定义报告（self:'BST'）->str:
“”“表示此二元搜索树。”“”
返回'BST（'+repr（self._root）+'）'
def find（self:'BST'，data:object）->BTNode:
“”“返回包含数据的节点，否则不返回任何数据。”“”
返回\u查找（self.\u根，数据）
def insert（自：“BST”，数据：对象）->无：
“”“如有必要，请将数据插入此树中。”。
>>>b=BST（）
>>>b.插入（8）
>>>b.插入（4）
>>>b.插入（2）
>>>b.插入（6）
>>>b.插入（12）
>>>b.插入（14）
>>>b.插入（10）
>>>b
BST（BTNode（8，BTNode（4，BTNode（2，无，无），BTNode（6，无，无）），BTNode（12，BTNode（10，无，无），BTNode（14，无，无）））
"""
self.\u root=\u insert（self.\u root，数据）
def高度（自：“BST”）->int:
“”“返回此树的高度。”“”
返回高度（自根）
def_insert（节点：BTNode，数据：object）->BTNode:
“”“如有必要，在节点上根目录的BST中插入数据，并返回根目录。”“”
如果不是节点：
返回BTNode（数据）
elif数据<节点数据：
node.left=\u插入（node.left，数据）
elif data>node.data：
node.right=\u插入（node.right，数据）
其他：#无事可做
通过
返回节点
def_find（节点：BTNode，数据：object）：
“”“返回包含数据的节点，否则不返回数据。”“”
如果不是node或node.data==数据：
返回节点
其他：
如果数据<节点数据：
return\u find（node.left，data）
其他：
return\u find（node.right，data）
def_高度（节点）：
“”“返回在节点上根目录树的高度。”“”
如果不是node或node.is_leaf（）：
返回0
左h=0
右h=0
如果node.left：
left_h=_高度（node.left）
如果node.right：
right\u h=\u高度（node.right）
返回最大值（左、右）+1
类BTNode：
“”“二叉树节点。”“”
定义初始化（self:'BTNode'，数据：对象，
左：“BTNode”=无，右：“BTNode”=无）->无：
“”“创建具有左右数据和子节点的BT节点。”“”
self.data，self.left，self.right=数据，左，右
定义报告（self:'BTNode'）->str:
“”“将此节点表示为字符串。”“”
return（'BTNode（'+str（self.data）+'，'+repr（self.left）+
“，”+repr（self.right）+“）”）
def是_leaf（self:'BTNode'）->bool:
“”“Return True节点是叶”“”
返回not self.left和not self.right

一棵树，每个节点可以有任意数量的子节点，当然不需要平衡

二叉树是每个节点都可以有0..2个子节点的树

BST与二叉树相同，但保证左侧的节点比当前节点小，右侧的节点更大

class BST:

def __init__(self: 'BST', root: BTNode=None) -> None:
    """Create BST with BTNode root."""
    self._root = root

def __repr__(self: 'BST') -> str:
    """Represent this binary search tree."""
    return 'BST(' + repr(self._root) + ')'

def find(self: 'BST', data: object) -> BTNode:
    """Return node containing data, otherwise return None."""
    return _find(self._root, data)

def insert(self: 'BST', data: object) -> None:
    """Insert data, if necessary, into this tree.

    >>> b = BST()
    >>> b.insert(8)
    >>> b.insert(4)
    >>> b.insert(2)
    >>> b.insert(6)
    >>> b.insert(12)
    >>> b.insert(14)
    >>> b.insert(10)
    >>> b
    BST(BTNode(8, BTNode(4, BTNode(2, None, None), BTNode(6, None, None)), BTNode(12, BTNode(10, None, None), BTNode(14, None, None))))
"""
    self._root = _insert(self._root, data)

def height(self: 'BST') -> int:
    """Return height of this tree."""
    return _height(self._root)

def _insert(node: BTNode, data: object) -> BTNode:
    """Insert data in BST rooted at node, if necessary, and return root."""
    if not node:
        return BTNode(data)
    elif data < node.data:
        node.left = _insert(node.left, data)
    elif data > node.data:
        node.right = _insert(node.right, data)
    else:  # nothing to do
        pass
return node

def _find(node: BTNode, data: object):
    """Return the node containing data, or else None."""
    if not node or node.data == data:
        return node
    else:
        if data < node.data:
            return _find(node.left, data)
        else:
            return _find(node.right, data)

def _height(node):
    """Return height of tree rooted at node."""
    if not node or node.is_leaf():
        return 0
    left_h = 0
    right_h = 0
    if node.left:
        left_h = _height(node.left)
    if node.right:
        right_h = _height(node.right)
    return max(left_h, right_h) + 1    

class BTNode:
"""Binary Tree node."""

def __init__(self: 'BTNode', data: object,
             left: 'BTNode'=None, right: 'BTNode'=None) -> None:
    """Create BT node with data and children left and right."""
    self.data, self.left, self.right = data, left, right

def __repr__(self: 'BTNode') -> str:
    """Represent this node as a string."""
    return ('BTNode(' + str(self.data) + ', ' + repr(self.left) +
            ', ' + repr(self.right) + ')')

def is_leaf(self: 'BTNode') -> bool:
    """Return True iff BTNode is a leaf"""
    return not self.left and not self.right