JZ18 二叉树的镜像

感觉并没有用到队列或栈的什么特性，就是把每个节点的左右子树交换一下

思路一：栈实现

public class Solution {
    public TreeNode Mirror (TreeNode pRoot) {
        if(pRoot==null)
            return null;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(pRoot);
        while(!stack.isEmpty())
        {
            TreeNode node = stack.pop();
            if(node.left!=null)
                stack.push(node.left);
            if(node.right!=null)
                stack.push(node.right);
            TreeNode temp=node.left;
            node.left=node.right;
            node.right=temp;
        }
        return pRoot;
    }
}

思路二：队列实现

代码实现如下：

public class Solution {
    public TreeNode Mirror (TreeNode pRoot) {
        // write code here
        if(pRoot==null)
            return null;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(pRoot);
        while(queue.size()>0)
        {
                TreeNode node=queue.poll();
                if(node.left!=null)
                    queue.add(node.left);
                if(node.right!=null)
                    queue.add(node.right);
                TreeNode temp=node.left;
                node.left =node.right;
                node.right=temp;
        }
        return pRoot;
    }
}

时间复杂度O(N)：遍历树的所有节点，占用 O(N) 时间。

空间复杂度O(N)：最差情况下，栈 最多同时存储（N + 1）/ 2 个节点，占用 O(N)额外空间。

思路三：递归实现

终止条件

递归前做什么

递归

    public TreeNode Mirror (TreeNode pRoot) {
        if(pRoot==null)
            return null;
        TreeNode temp=pRoot.left;
        pRoot.left=pRoot.right;
        pRoot.right=temp;
        TreeNode left=Mirror(pRoot.left);
        TreeNode right=Mirror(pRoot.right);
        return pRoot;
    }
}

时间遍历每个节点O(N),空间最差情况下（当二叉树退化为链表），递归时系统需使用O(N) 大小的栈空间