python二叉树代码

Python 中创建二叉树通常会使用递归的方式来实现，这里有一个简单的二叉树节点类和插入构建二叉树的例子：

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

# 插入节点并构建二叉树
def insert IntoBST(root, val):
    if not root:
        return TreeNode(val)
    elif val < root.val:
        root.left = insert_into_BST(root.left, val)
    else:
        root.right = insert_into_BST(root.right, val)
    return root

# 示例
root = None
values = [5, 3, 7, 1, 4, 6, 8]
for value in values:
    root = insertIntoBST(root, value)

# 这里只是一个基本的结构，你可以添加遍历、查找等操作来完成更多的功能

这个代码首先定义了一个`TreeNode`类来表示二叉树的节点，包含值和左右子节点。然后通过`insertIntoBST`函数递归地向左或向右插入新节点，直到找到合适的空位置。

相关问题

Python二叉树代码

以下是一个简单的 Python 二叉树实现代码，包含节点类和树类：

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

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

    def insert(self, val):
        if not self.root:
            self.root = Node(val)
        else:
            self._insert(val, self.root)

    def _insert(self, val, cur_node):
        if val < cur_node.val:
            if not cur_node.left:
                cur_node.left = Node(val)
            else:
                self._insert(val, cur_node.left)
        elif val > cur_node.val:
            if not cur_node.right:
                cur_node.right = Node(val)
            else:
                self._insert(val, cur_node.right)

    def search(self, val):
        if not self.root:
            return False
        else:
            return self._search(val, self.root)

    def _search(self, val, cur_node):
        if val == cur_node.val:
            return True
        elif val < cur_node.val and cur_node.left:
            return self._search(val, cur_node.left)
        elif val > cur_node.val and cur_node.right:
            return self._search(val, cur_node.right)
        return False

以上代码实现了二叉树的基本功能，包括插入节点和查找节点。你可以根据自己的需要修改代码来满足其他功能的需求。

python二叉树遍历代码

以下是Python实现二叉树遍历的代码示例：

定义二叉树节点类：

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

先序遍历：

def preorderTraversal(root):
    if not root:
        return []
    res = []
    stack = [root]
    while stack:
        node = stack.pop()
        res.append(node.val)
        if node.right:
            stack.append(node.right)
        if node.left:
            stack.append(node.left)
    return res

中序遍历：

def inorderTraversal(root):
    if not root:
        return []
    res = []
    stack = []
    while stack or root:
        while root:
            stack.append(root)
            root = root.left
        node = stack.pop()
        res.append(node.val)
        root = node.right
    return res

后序遍历：

def postorderTraversal(root):
    if not root:
        return []
    res = []
    stack = [root]
    while stack:
        node = stack.pop()
        res.append(node.val)
        if node.left:
            stack.append(node.left)
        if node.right:
            stack.append(node.right)
    return res[::-1]

其中，先序遍历和后序遍历使用了栈的思想，中序遍历使用了递归的方式。