求解二叉树镜像

一，问题介绍

求解一棵二叉树的镜像。所谓镜像，就是从二叉树的根到叶结点的每一层，将所有的非叶子结点的孩子进行交换。

比如说，下面两棵二叉树互为镜像：

 

二，算法分析

/**
     * 递归求解二叉树的镜像
     * @param root
     */
    public void mirrorRecursively(BinaryNode<T> root){
        //base condition
        if(root == null || (root.left == null && root.right == null))
            return;
        
        //swap nodes
        BinaryNode<T> tmp;
        tmp = root.left;
        root.left = root.right;
        root.right = tmp;
        
        //recursively call
        if(root.left != null)
            mirrorRecursively(root.left);
        if(root.right != null)
            mirrorRecursively(root.right);
    }

从根结点开始，先交换根结点的左右孩子， 然后再依次交换根结点的左右孩子的孩子......

时间复杂度分析：由于每个结点都会遍历一次，故时间复杂度为O(N)，也可以列出递归表达式如下：

递归表达式：T(N)=2T(N/2)+O(1). 由17行到20行的两个if语句，可知将问题规模为N分解成了两个规模为N/2的两个子问题；附加的处理规模为O(1)

解得T(N)=O(N)

尾递归转化为循环：

/**
     * 循环实现 求解二叉树的镜像
     * @param root
     */
    public void mirrorLoop(BinaryNode<T> root){
        if(root == null || (root.left == null && root.right == null))
            return;
        
        swap(root.left, root.right, root);//根的左右孩子的交换
        
        //处理根的左子树的交换
        BinaryNode<T> currentNode = root;
        while(currentNode.left != null)
        {
            currentNode = currentNode.left;
            swap(currentNode.left, currentNode.right, currentNode);
        }

        //处理根的右子树的交换
        currentNode = root;
        while(currentNode.right != null)
        {
            currentNode = currentNode.right;
            swap(currentNode.left, currentNode.right, currentNode);
        }
    }

 

 

三，完整代码实现

递归实现和非递归实现。由于该递归是一个尾递归，故非递归实现也很简单。

public class BinaryTree_Mirror<T extends Comparable<? super T>> {
    
    private static class BinaryNode<T>{
        T element;
        BinaryNode<T> left;
        BinaryNode<T> right;
        
        public BinaryNode(T element) {
            this.element = element;
            left = right = null;
        }
        
        @Override
        public String toString() {
            return element.toString();
        }
    }
    
    private BinaryNode<T> root;
    
    /**
     * 向二叉树中插入一个元素
     * @param element
     */
    public void insert(T element){
        root = insert(root, element);
    }
    private BinaryNode<T> insert(BinaryNode<T> root, T element){
        if(root == null)
            return new BinaryNode<T>(element);
        int r = (int)(2*Math.random());
        //随机地将元素插入到左子树 或者 右子树中
        if(r==0)
            root.left = insert(root.left, element);
        else
            root.right = insert(root.right, element);
        return root;
    }
    
    public void inOrder(BinaryNode<T> root){
        //base condition
        if(root == null)
            return;
        
        inOrder(root.left);
        System.out.print(root + " ");//visit node
        inOrder(root.right);
    }
    
    
    /**
     * 递归求解二叉树的镜像
     * @param root
     */
    public void mirrorRecursively(BinaryNode<T> root){
        //base condition
        if(root == null || (root.left == null && root.right == null))
            return;
        
        //swap nodes
        BinaryNode<T> tmp;
        tmp = root.left;
        root.left = root.right;
        root.right = tmp;
        
        //recursively call
        if(root.left != null)
            mirrorRecursively(root.left);
        if(root.right != null)
            mirrorRecursively(root.right);
    }
    
    /**
     * 循环实现 求解二叉树的镜像
     * @param root
     */
    public void mirrorLoop(BinaryNode<T> root){
        if(root == null || (root.left == null && root.right == null))
            return;
        
        swap(root.left, root.right, root);
        
        BinaryNode<T> currentNode = root;
        while(currentNode.left != null)
        {
            currentNode = currentNode.left;
            swap(currentNode.left, currentNode.right, currentNode);
        }

        currentNode = root;
        while(currentNode.right != null)
        {
            currentNode = currentNode.right;
            swap(currentNode.left, currentNode.right, currentNode);
        }
    }
    
    /**
     * 交换currentNode的左右孩子结点
     * @param left
     * @param right
     * @param currentNode
     */
    private void swap(BinaryNode<T> left, BinaryNode<T> right, BinaryNode<T> currentNode){
        BinaryNode<T> tmpNode;
        tmpNode = currentNode.left;
        currentNode.left = currentNode.right;
        currentNode.right = tmpNode;
    }
    

    public static void main(String[] args) {
        BinaryTree_Mirror<Integer> tree1 = new BinaryTree_Mirror<>();
        BinaryTree_Mirror<Integer> tree2 = new BinaryTree_Mirror<>();
        
        int[] ele = C2_2_8.algorithm1(4);
        for (int i = 0; i < ele.length; i++) {
            tree1.insert(ele[i]);
            tree2.insert(ele[i]);
        }
        
        tree1.mirrorLoop(tree1.root);
        tree2.mirrorRecursively(tree2.root);
        
        tree1.inOrder(tree1.root);
        System.out.println();
        tree2.inOrder(tree2.root);
    }
}