求解二叉树镜像

 1 /**
 2      * 递归求解二叉树的镜像
 3      * @param root
 4      */
 5     public void mirrorRecursively(BinaryNode<T> root){
 6         //base condition
 7         if(root == null || (root.left == null && root.right == null))
 8             return;
 9         
10         //swap nodes
11         BinaryNode<T> tmp;
12         tmp = root.left;
13         root.left = root.right;
14         root.right = tmp;
15         
16         //recursively call
17         if(root.left != null)
18             mirrorRecursively(root.left);
19         if(root.right != null)
20             mirrorRecursively(root.right);
21     }

 1 /**
 2      * 循环实现 求解二叉树的镜像
 3      * @param root
 4      */
 5     public void mirrorLoop(BinaryNode<T> root){
 6         if(root == null || (root.left == null && root.right == null))
 7             return;
 8         
 9         swap(root.left, root.right, root);//根的左右孩子的交换
10         
11         //处理根的左子树的交换
12         BinaryNode<T> currentNode = root;
13         while(currentNode.left != null)
14         {
15             currentNode = currentNode.left;
16             swap(currentNode.left, currentNode.right, currentNode);
17         }
18 
19         //处理根的右子树的交换
20         currentNode = root;
21         while(currentNode.right != null)
22         {
23             currentNode = currentNode.right;
24             swap(currentNode.left, currentNode.right, currentNode);
25         }
26     }

  1 public class BinaryTree_Mirror<T extends Comparable<? super T>> {
  2     
  3     private static class BinaryNode<T>{
  4         T element;
  5         BinaryNode<T> left;
  6         BinaryNode<T> right;
  7         
  8         public BinaryNode(T element) {
  9             this.element = element;
 10             left = right = null;
 11         }
 12         
 13         @Override
 14         public String toString() {
 15             return element.toString();
 16         }
 17     }
 18     
 19     private BinaryNode<T> root;
 20     
 21     /**
 22      * 向二叉树中插入一个元素
 23      * @param element
 24      */
 25     public void insert(T element){
 26         root = insert(root, element);
 27     }
 28     private BinaryNode<T> insert(BinaryNode<T> root, T element){
 29         if(root == null)
 30             return new BinaryNode<T>(element);
 31         int r = (int)(2*Math.random());
 32         //随机地将元素插入到左子树 或者 右子树中
 33         if(r==0)
 34             root.left = insert(root.left, element);
 35         else
 36             root.right = insert(root.right, element);
 37         return root;
 38     }
 39     
 40     public void inOrder(BinaryNode<T> root){
 41         //base condition
 42         if(root == null)
 43             return;
 44         
 45         inOrder(root.left);
 46         System.out.print(root + " ");//visit node
 47         inOrder(root.right);
 48     }
 49     
 50     
 51     /**
 52      * 递归求解二叉树的镜像
 53      * @param root
 54      */
 55     public void mirrorRecursively(BinaryNode<T> root){
 56         //base condition
 57         if(root == null || (root.left == null && root.right == null))
 58             return;
 59         
 60         //swap nodes
 61         BinaryNode<T> tmp;
 62         tmp = root.left;
 63         root.left = root.right;
 64         root.right = tmp;
 65         
 66         //recursively call
 67         if(root.left != null)
 68             mirrorRecursively(root.left);
 69         if(root.right != null)
 70             mirrorRecursively(root.right);
 71     }
 72     
 73     /**
 74      * 循环实现 求解二叉树的镜像
 75      * @param root
 76      */
 77     public void mirrorLoop(BinaryNode<T> root){
 78         if(root == null || (root.left == null && root.right == null))
 79             return;
 80         
 81         swap(root.left, root.right, root);
 82         
 83         BinaryNode<T> currentNode = root;
 84         while(currentNode.left != null)
 85         {
 86             currentNode = currentNode.left;
 87             swap(currentNode.left, currentNode.right, currentNode);
 88         }
 89 
 90         currentNode = root;
 91         while(currentNode.right != null)
 92         {
 93             currentNode = currentNode.right;
 94             swap(currentNode.left, currentNode.right, currentNode);
 95         }
 96     }
 97     
 98     /**
 99      * 交换currentNode的左右孩子结点
100      * @param left
101      * @param right
102      * @param currentNode
103      */
104     private void swap(BinaryNode<T> left, BinaryNode<T> right, BinaryNode<T> currentNode){
105         BinaryNode<T> tmpNode;
106         tmpNode = currentNode.left;
107         currentNode.left = currentNode.right;
108         currentNode.right = tmpNode;
109     }
110     
111 
112     public static void main(String[] args) {
113         BinaryTree_Mirror<Integer> tree1 = new BinaryTree_Mirror<>();
114         BinaryTree_Mirror<Integer> tree2 = new BinaryTree_Mirror<>();
115         
116         int[] ele = C2_2_8.algorithm1(4);
117         for (int i = 0; i < ele.length; i++) {
118             tree1.insert(ele[i]);
119             tree2.insert(ele[i]);
120         }
121         
122         tree1.mirrorLoop(tree1.root);
123         tree2.mirrorRecursively(tree2.root);
124         
125         tree1.inOrder(tree1.root);
126         System.out.println();
127         tree2.inOrder(tree2.root);
128     }
129 }