写一段平衡二叉树中深度优先搜索的代码

以下是平衡二叉树中深度优先搜索的代码（使用递归实现）：

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

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

    def insert(self, val):
        self.root = self._insert(self.root, val)

    def _insert(self, node, val):
        if not node:
            return Node(val)
        if val < node.val:
            node.left = self._insert(node.left, val)
        else:
            node.right = self._insert(node.right, val)
        
        node = self._balance(node)
        return node

    def _balance(self, node):
        if not node:
            return node
        
        # 计算平衡因子
        balance_factor = self._height(node.left) - self._height(node.right)
        
        # 如果平衡因子小于-1，说明右子树高度较高，需要左旋转
        if balance_factor < -1:
            # 如果右子树的左子树高度大于右子树的右子树高度，需要先右旋转
            if self._height(node.right.left) > self._height(node.right.right):
                node.right = self._right_rotate(node.right)
            node = self._left_rotate(node)
        # 如果平衡因子大于1，说明左子树高度较高，需要右旋转
        elif balance_factor > 1:
            # 如果左子树的右子树高度大于左子树的左子树高度，需要先左旋转
            if self._height(node.left.right) > self._height(node.left.left):
                node.left = self._left_rotate(node.left)
            node = self._right_rotate(node)

        return node

    def _left_rotate(self, node):
        new_root = node.right
        node.right = new_root.left
        new_root.left = node
        return new_root

    def _right_rotate(self, node):
        new_root = node.left
        node.left = new_root.right
        new_root.right = node
        return new_root

    def _height(self, node):
        if not node:
            return 0
        return 1 + max(self._height(node.left), self._height(node.right))

    def dfs(self):
        res = []
        self._dfs(self.root, res)
        return res

    def _dfs(self, node, res):
        if not node:
            return
        res.append(node.val)
        self._dfs(node.left, res)
        self._dfs(node.right, res)

其中，`_dfs` 方法使用递归实现深度优先搜索，返回一个列表，表示遍历的结果。在遍历每个节点时，将节点的值添加到结果列表中，然后递归遍历左子树和右子树。