使用栈来实现二叉树的反转(invert)

最近在刷leetcode,碰到这样一道题

这题并不难，如果用递归的话半分钟就能搞定。不过感觉递归效率比较低，因为递归可以用栈来实现，于是琢磨能不能用栈来搞定。
这是用递归的解法:

// 递归算法
    public TreeNode invertTree(TreeNode root) {
        if (root==null) return null ;
        TreeNode temp = root.left ;
        root.left = root.right ;
        root.right = temp ;
        invertTree(root.left) ;
        invertTree(root.right) ;
        return root ;
    }这里写代码片

下面是使用栈实现的解法

// 用栈实现的算法
    public TreeNode invertTree(TreeNode root){
        if (root==null) return null ;
        Stack<TreeNode> stack = new Stack<TreeNode>() ;
        stack.push(root) ;
        TreeNode latestNode=null ;
        while (!stack.isEmpty()){
            TreeNode node = stack.peek() ;

            if (node.left == null){
                if (node.right == null){
                    // 左右为空，这是个叶节点
                    latestNode = stack.pop() ;
                }else if (node.right == latestNode){
                    // 如果右边不为空，且刚出栈，表示该节点处理完毕
                    // 交换左右，并出栈
                    node.left = node.right ;
                    node.right = null ;
                    latestNode = stack.pop() ;
                }else{
                    // 否则将右节点压入栈中
                    stack.push(node.right) ;
                }
            }
            else if (node.right == null){
                // 这里描述的是左节点不为空，右节点为空的情况
                if (node.left == latestNode){
                    // 如果左节点刚出栈
                    // 则交换顺序，然后自己也出栈
                    node.right = node.left ;
                    node.left = null ;
                    latestNode = stack.pop() ;
                }else{
                    stack.push(node.left) ;
                }
            }
            else{
                // 当左右节点均不为空时
                if (node.right == latestNode){
                    // 右节点刚出栈
                    TreeNode temp = node.left ;
                    temp = node.left ;
                    node.left = node.right ;
                    node.right = temp ;
                    latestNode = stack.pop();
                }
                else if (node.left == latestNode) {
                    stack.push(node.right) ;
                }
                else {
                    stack.push(node.left) ;
                }
            }
        }
        return root ;
    }

一个悲伤的消息是。。。改成用栈实现后。。。运行效率更低了=。= 看来java对递归的优化还不错