二叉搜索树的递归插入，python代码

下面是Python中实现二叉搜索树的递归插入代码：

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def insertIntoBST(self, root: TreeNode, val: int) -> TreeNode:
        if not root:
            return TreeNode(val)
        if val < root.val:
            root.left = self.insertIntoBST(root.left, val)
        else:
            root.right = self.insertIntoBST(root.right, val)
        return root

其中，`TreeNode`类表示二叉树节点，包含三个属性：`val`表示节点值，`left`表示左子节点，`right`表示右子节点。

`Solution`类中的`insertIntoBST`方法是递归实现的二叉搜索树插入操作。如果当前节点为空，则创建一个新节点并返回；如果插入值小于当前节点的值，则递归插入到左子树；否则递归插入到右子树。最后返回根节点。

相关问题

二叉搜索树的递归插入，python

好的，以下是二叉搜索树的递归插入的 Python 代码：

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
        
def insertIntoBST(root, val):
    if not root:
        return TreeNode(val)
    if val < root.val:
        root.left = insertIntoBST(root.left, val)
    else:
        root.right = insertIntoBST(root.right, val)
    return root

其中，`TreeNode` 是二叉树节点的类，包含节点的值 `val`，左子树 `left` 和右子树 `right`。`insertIntoBST` 函数接受一个指向根节点的指针 `root` 和要插入的值 `val`，返回插入后的根节点。

如果根节点为空，直接将新节点作为根节点返回。如果 `val` 小于根节点的值，递归插入到左子树中；否则递归插入到右子树中。最后返回根节点即可。

希望能帮到你！

二叉搜索树 python

二叉搜索树是一种有序的二叉树，其中每个节点的值都大于其左子树中任何节点的值，小于其右子树中任何节点的值。

以下是一个简单的二叉搜索树的 Python 实现：

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class BST:
    def __init__(self):
        self.root = None

    def insert(self, val):
        """
        向二叉搜索树中插入一个节点
        """
        if not self.root:
            self.root = TreeNode(val)
        else:
            self._insert(val, self.root)

    def _insert(self, val, node):
        """
        递归插入节点
        """
        if val < node.val:
            if not node.left:
                node.left = TreeNode(val)
            else:
                self._insert(val, node.left)
        else:
            if not node.right:
                node.right = TreeNode(val)
            else:
                self._insert(val, node.right)

    def search(self, val):
        """
        在二叉搜索树中查找一个节点
        """
        return self._search(val, self.root)

    def _search(self, val, node):
        """
        递归查找节点
        """
        if not node:
            return False
        elif node.val == val:
            return True
        elif val < node.val:
            return self._search(val, node.left)
        else:
            return self._search(val, node.right)

    def delete(self, val):
        """
        在二叉搜索树中删除一个节点
        """
        self.root = self._delete(val, self.root)

    def _delete(self, val, node):
        """
        递归删除节点
        """
        if not node:
            return None
        elif val < node.val:
            node.left = self._delete(val, node.left)
        elif val > node.val:
            node.right = self._delete(val, node.right)
        else:
            if not node.left:
                return node.right
            elif not node.right:
                return node.left
            else:
                temp = self._find_min(node.right)
                node.val = temp.val
                node.right = self._delete(temp.val, node.right)
        return node

    def _find_min(self, node):
        """
        找到以给定节点为根的子树中的最小节点
        """
        while node.left:
            node = node.left
        return node

这个实现包含了插入、查找和删除操作。其中，插入和查找操作都是使用递归实现的，而删除操作则需要一些额外的处理，因为需要维护二叉搜索树的结构。