使用kotlin解决这个问题：104. 二叉树的最大深度 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 示例： 给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7 返回它的最大深度 3 。

好的，下面是使用 Kotlin 解决该问题的代码：

class Solution {
    fun maxDepth(root: TreeNode?): Int {
        if (root == null) {
            return 0
        }
        val leftDepth = maxDepth(root.left)
        val rightDepth = maxDepth(root.right)
        return Math.max(leftDepth, rightDepth) + 1
    }
}

其中，maxDepth 函数采用递归解法，当节点为空时，返回深度为 0；否则，分别计算左子树和右子树的最大深度，然后取其中较大值加 1 即为当前节点的最大深度。

相关问题

使用kotlin解决这个问题：94. 二叉树的中序遍历 给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。 示例 1： 输入：root = [1,null,2,3] 输出：[1,3,2] 示例 2： 输入：root = [] 输出：[] 示例 3： 输入：root = [1] 输出：[1] 提示： 树中节点数目在范围 [0, 100] 内 -100 <= Node.val <= 100

好的，这是一个二叉树的中序遍历问题，可以使用递归或迭代的方式来解决。以下是使用 Kotlin 语言的递归代码实现：

class TreeNode(var `val`: Int) {
    var left: TreeNode? = null
    var right: TreeNode? = null
}

fun inorderTraversal(root: TreeNode?): List<Int> {
    val result = mutableListOf<Int>()
    if (root == null) {
        return result
    }
    result.addAll(inorderTraversal(root.left))
    result.add(root.`val`)
    result.addAll(inorderTraversal(root.right))
    return result
}

以上代码中，我们首先创建了一个 TreeNode 类来表示二叉树的节点。然后我们定义了一个名为 `inorderTraversal` 的函数，它接收一个 TreeNode 类型的参数 `root`，表示二叉树的根节点。函数返回一个 Int 类型的列表，包含了二叉树的中序遍历结果。

在函数内部，我们首先创建一个空的列表 `result`，如果输入的根节点为 null，则直接返回空列表。接着，我们对二叉树进行中序遍历，即先递归遍历左子树，再将当前节点的值加入到结果列表中，最后递归遍历右子树。最后返回结果列表。

如果要测试以上代码，可以使用以下代码：

fun main() {
    val root = TreeNode(1)
    root.right = TreeNode(2)
    root.right?.left = TreeNode(3)
    println(inorderTraversal(root)) // 输出 [1, 3, 2]
}

在测试代码中，我们首先创建了一个二叉树，然后调用 `inorderTraversal` 函数，并将其结果打印出来。

使用kotlin解决这个问题：993. 二叉树的堂兄弟节点 简单 297 相关企业 在二叉树中，根节点位于深度 0 处，每个深度为 k 的节点的子节点位于深度 k+1 处。 如果二叉树的两个节点深度相同，但 父节点不同 ，则它们是一对堂兄弟节点。 我们给出了具有唯一值的二叉树的根节点 root ，以及树中两个不同节点的值 x 和 y 。 只有与值 x 和 y 对应的节点是堂兄弟节点时，才返回 true 。否则，返回 false。

可以使用BFS（广度优先搜索）来解决这个问题。具体来说，我们可以先对根节点进行 BFS，找出节点 x 和 y，以及它们的深度和父节点。如果 x 和 y 深度相同且父节点不同，那么它们就是堂兄弟节点。

代码如下：

class Solution {
    fun isCousins(root: TreeNode?, x: Int, y: Int): Boolean {
        if (root == null) return false
        
        val queue = LinkedList<Pair<TreeNode, Int>>() // 队列保存节点和深度
        queue.offer(Pair(root, 0))
        
        var xDepth = -1 // x节点的深度
        var yDepth = -1 // y节点的深度
        var xParent: TreeNode? = null // x节点的父节点
        var yParent: TreeNode? = null // y节点的父节点
        
        while (queue.isNotEmpty()) {
            val size = queue.size
            for (i in 0 until size) {
                val (node, depth) = queue.poll()

                if (node.left != null) {
                    if (node.left!!.`val` == x) {
                        xDepth = depth + 1
                        xParent = node
                    } else if (node.left!!.`val` == y) {
                        yDepth = depth + 1
                        yParent = node
                    }
                    queue.offer(Pair(node.left!!, depth + 1))
                }
                
                if (node.right != null) {
                    if (node.right!!.`val` == x) {
                        xDepth = depth + 1
                        xParent = node
                    } else if (node.right!!.`val` == y) {
                        yDepth = depth + 1
                        yParent = node
                    }
                    queue.offer(Pair(node.right!!, depth + 1))
                }
            }
            
            if (xDepth != -1 && yDepth != -1) { // 如果 x 和 y 都找到了
                break
            }
        }
        
        return xDepth == yDepth && xParent != yParent
    }
}

这里使用了一个 Pair 类来同时保存节点和深度信息，这样就不用定义一个新的类了。