15.输入一颗二元查找树，将该树转换为它的镜像， 即在转换后的二元查找树中，左子树的结点都大于右子树的结点， 用递归和循环两种方法完成树的镜像转换

转载请注明出处：http://www.cnblogs.com/wuzetiandaren/p/4260432.html 

声明：现大部分文章为寻找问题时在网上相互转载，此博是为自己做个记录记录，方便自己也方便有类似问题的朋友，本文的思想也许有所借鉴，但源码均为本人实现，如有侵权，请发邮件表明文章和原出处地址，我一定在文章中注明。谢谢。

题目：输入一颗二元查找树，将该树转换为它的镜像， 即在转换后的二元查找树中，左子树的结点都大于右子树的结点， 用递归和循环两种方法完成树的镜像转换。

题目分析：

　　注：二叉排序树的中序遍历结果是升序排序的，因此将该树转换为它的镜像之后，该树的中序遍历结果应是降序排序的。

　　一、递归实现：

　　这种方式相对比较好实现，传入树的根节点，当节点不为空时，交换根节点的左右孩子，再递归交换左右子树的左右孩子。

　　算法实现：

    private void exchangeRecursive(Node root){
        if(root!=null){    
            swap(root);         //交换根节点的左右子树
            exchangeRecursive(root.left);  //递归交换左子树
            exchangeRecursive(root.right); //递归交换右子树
        }
    }

　　二、循环方式实现：

　　这种方式相对比较麻烦，下面给出两种实现方式：

　　（一）、借助先序遍历交换(后序遍历与此类似)，可以用一个LinkedList的数据结构模拟栈来完成此操作。传入树的根节点root。

　　1.如果root为空则结束交换，否则root 进栈。

　　2.当栈不为空时进行如下操作：

　　　　a.弹出栈顶节点，交换栈顶节点的左右孩子。

　　　　b.如果栈顶元素的右孩子不为空，右孩子节点进栈；如果栈顶元素的左孩子不为空，左孩子节点进栈。

　　算法实现：

    //运用先序遍历循环将该树转换为它的镜像,用LinkedList模拟栈来实现 DLR
    private void exchangeCirculatory(Node root){
        if(root==null){
            return;
        }
        LinkedList<Node> nodelist = new LinkedList<Node>();
        System.out.println();
        nodelist.add(root);           //根节点进栈
        while(nodelist.size()!=0){
            root = nodelist.removeLast(); //获得栈顶元素
            swap(root);
            if(root.right!=null){     //如果栈顶元素的右孩子不为空，右孩子节点进栈
                nodelist.add(root.right);
            }
            if(root.left!=null){     //如果栈顶元素的左孩子不为空，左孩子节点进栈
                nodelist.add(root.left);
            }
        }
    }

　　（二）、借助层序遍历交换，可以用一个LinkedList的数据结构模拟队列来完成此操作。传入树的根节点root。

　　1.如果root为空则结束交换，否则root 入队。

　　2.当队列不为空时进行如下操作：

　　　　a.队首元素出队，交换队首元素节点的左右孩子。

　　　　b.如果队首元素的左孩子不为空，左孩子节点入队；如果队首元素的右孩子不为空，右孩子节点进栈。

算法实现：

    //层序遍历循环将该树转换为它的镜像,使用LinkedList数据结构来模拟队列
    private void levelOrder(Node root){
        if(root==null){
            System.out.println("
二叉树为空！");
            return;
        }
        System.out.println("
这是二叉排序树的层序遍历结果:");
        LinkedList<Node> queue = new LinkedList<Node>();
        queue.add(root);      //根节点先入队
        while(queue.size()!=0){
            Node node = queue.removeFirst();  //得到并删除队列的第一个节点
            swap(node);
            if(node.left!=null){   //该节点的左孩子入队
                queue.add(node.left);
            }
            if(node.right!=null){   //该节点的右孩子入队
                queue.add(node.right);
            }
        }
        System.out.println();
    }

java实现的完整源码：

package com.interview;

import java.util.LinkedList;

import com.interview._16LeverOrder.Node;

/**
 * 题目:输入一颗二元查找树，将该树转换为它的镜像，
 *     即在转换后的二元查找树中，左子树的结点都大于右子树的结点。
 *     用递归和循环两种方法完成树的镜像转换。
 * @author wjh
 *
 */
public class _15MirrorTree {

    /**
     * @param args
     */
    public static void main(String[] args) {
        _15MirrorTree builder= new _15MirrorTree();
        int[] a = {56,45,47,67,35,76,22,89,91,27,11,21,19,87};
        Node root = null;
        root = builder.buildTree(root, a); //1)创建二叉排序树
        System.out.println("这是原二叉树的中序遍历结果:");
        builder.inOrder(root);   //2)打印交换之前的二叉排序树的中序遍历结果
        
        builder.exchangeRecursive(root);  //3)递归交换二叉排序树的左右子树
        System.out.println("

这是用递归将该树转换为它的镜像的中序遍历结果:");
        builder.inOrder(root);   //4)打印递归交换之后的二叉排序树的中序遍历结果
        
        builder.exchangeRecursive(root);  //5)将树转换回原二叉排序树
        builder.exchangeCirculatory(root);//6)循环交换二叉排序树的左右子树
        System.out.println("
这是借助先序遍历循环将该树转换为它的镜像的中序遍历结果:");
        builder.inOrder(root);  //7)打印循环交换之后的二叉排序树的中序遍历结果
        
        builder.exchangeRecursive(root);  //8)将树转换回原二叉排序树
        builder.levelOrder(root);    //9)层序交换二叉排序树的左右子树
        System.out.println("
这是借助层序循环将该树转换为它的镜像的中序遍历结果:");
        builder.inOrder(root);  //10)打印循环交换之后的二叉排序树的中序遍历结果
    }    
    
    //运用递归将该树转换为它的镜像
    private void exchangeRecursive(Node root){
        if(root!=null){    
            swap(root);         //交换根节点的左右子树
            exchangeRecursive(root.left);  //递归交换左子树
            exchangeRecursive(root.right); //递归交换右子树
        }
    }
    
    //运用先序遍历循环将该树转换为它的镜像,用LinkedList模拟栈来实现 DLR
    private void exchangeCirculatory(Node root){
        if(root==null){
            return;
        }
        LinkedList<Node> nodelist = new LinkedList<Node>();
        System.out.println();
        nodelist.add(root);           //根节点进栈
        while(nodelist.size()!=0){
            root = nodelist.removeLast(); //获得栈顶元素
            swap(root);
            if(root.right!=null){     //如果栈顶元素的右孩子不为空，右孩子节点进栈
                nodelist.add(root.right);
            }
            if(root.left!=null){     //如果栈顶元素的左孩子不为空，左孩子节点进栈
                nodelist.add(root.left);
            }
        }
    }
    
    //层序遍历循环将该树转换为它的镜像,使用LinkedList数据结构来模拟队列
    private void levelOrder(Node root){
        if(root==null){
            System.out.println("
二叉树为空！");
            return;
        }
        LinkedList<Node> queue = new LinkedList<Node>();
        queue.add(root);      //根节点先入队
        while(queue.size()!=0){
            Node node = queue.removeFirst();  //得到并删除队列的第一个节点
            swap(node);
            if(node.left!=null){   //该节点的左孩子入队
                queue.add(node.left);
            }
            if(node.right!=null){   //该节点的右孩子入队
                queue.add(node.right);
            }
        }
        System.out.println();
    }
    
    //交换节点的左右子树
    private void swap(Node root){
        Node temp = root.left; 
        root.left = root.right;
        root.right = temp;
    }
    
    //二叉树的中序遍历
    private void inOrder(Node root){
        if(root==null){
            return;            
        }
        else{
            inOrder(root.left);
            System.out.print(root.data+" ");
            inOrder(root.right);
        }
    }
    
    //建二叉排序树
    private Node buildTree(Node root, int[] data) {
        for (int i = 0; i < data.length; i++) {
        root=insert(root, data[i]);
        }
        return root;
     }
                
    //一次插入节点
    private Node insert(Node node, int data) {
        if (node == null) {
            node = new Node(data,null,null);
         }else{ 
            if(data <= node.data) {
                node.left = insert(node.left, data);
             } else {
                node.right = insert(node.right, data);
             }
         }
         return node;
    }
    
    //创建一个树节点类
    class Node {
        public int data;
        public Node left;  //指向左孩子的指针    
        public Node right;  //指向右孩子的指针    
        public Node() {
            super();
        }
        public Node(int data, Node left, Node right) {
            super();
            this.data = data;
            this.left = left;
            this.right = right;
        }
    }

}

运行结果：

这是原二叉树的中序遍历结果:
11 19 21 22 27 35 45 47 56 67 76 87 89 91

这是用递归将该树转换为它的镜像的中序遍历结果:
91 89 87 76 67 56 47 45 35 27 22 21 19 11

这是借助先序遍历循环将该树转换为它的镜像的中序遍历结果:
91 89 87 76 67 56 47 45 35 27 22 21 19 11

这是借助层序循环将该树转换为它的镜像的中序遍历结果:
91 89 87 76 67 56 47 45 35 27 22 21 19 11