使用kotlin解决这个问题：226. 翻转二叉树 简单 1.6K 相关企业 给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。 示例 1： 输入：root = [4,2,7,1,3,6,9] 输出：[4,7,2,9,6,3,1] 示例 2： 输入：root = [2,1,3] 输出：[2,3,1] 示例 3： 输入：root = [] 输出：[] 提示： 树中节点数目范围在 [0, 100] 内 -100 <= Node.val <= 100 通过次数 669.4K 提交次数 841.7K 通过率 79.5%

可以使用递归实现二叉树的翻转，具体代码如下：

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

fun invertTree(root: TreeNode?): TreeNode? {
    if (root == null) {
        return null
    }
    val left = root.left
    val right = root.right
    root.left = invertTree(right)
    root.right = invertTree(left)
    return root
}

首先判断根节点是否为空，如果为空直接返回null；否则将根节点的左右子树通过递归分别翻转，并交换左右子树的位置，最后返回翻转后的根节点。

相关问题

请用kotlin解决这个问题：101. 对称二叉树 给你一个二叉树的根节点 root ， 检查它是否轴对称。 示例 1： 输入：root = [1,2,2,3,4,4,3] 输出：true 示例 2： 输入：root = [1,2,2,null,3,null,3] 输出：false 提示： 树中节点数目在范围 [1, 1000] 内 -100 <= Node.val <= 100 进阶：你可以运用递归和迭代两种方法解决这个问题吗？

好的，下面是用 Kotlin 解决该问题的代码，其中包含了递归和迭代两种解法：

class Solution {
    // 递归解法
    fun isSymmetric(root: TreeNode?): Boolean {
        return isMirror(root, root)
    }

    private fun isMirror(t1: TreeNode?, t2: TreeNode?): Boolean {
        if (t1 == null && t2 == null) {
            return true
        }
        if (t1 == null || t2 == null) {
            return false
        }
        return t1.`val` == t2.`val` && isMirror(t1.left, t2.right) && isMirror(t1.right, t2.left)
    }

    // 迭代解法
    fun isSymmetric2(root: TreeNode?): Boolean {
        if (root == null) {
            return true
        }
        val queue = LinkedList<TreeNode?>()
        queue.offer(root.left)
        queue.offer(root.right)
        while (queue.isNotEmpty()) {
            val t1 = queue.poll()
            val t2 = queue.poll()
            if (t1 == null && t2 == null) {
                continue
            }
            if (t1 == null || t2 == null || t1.`val` != t2.`val`) {
                return false
            }
            queue.offer(t1.left)
            queue.offer(t2.right)
            queue.offer(t1.right)
            queue.offer(t2.left)
        }
        return true
    }
}

其中，isSymmetric 函数采用递归解法，isSymmetric2 函数采用迭代解法。

使用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` 函数，并将其结果打印出来。