首先初始化一棵樹

 1 public class Node {
 2     //數據
 3     private int data;
 4     //左孩子
 5     private Node leftNode;
 6     //右孩子
 7     private Node rightNode;
 8     public Node(int data, Node leftNode, Node rightNode){
 9         this.data = data;
10         this.leftNode = leftNode;
11         this
 
.rightNode = rightNode;
12     }
13 
14     public int getData() {
15         return data;
16     }
17     public void setData(int data) {
18         this.data = data;
19     }
20     public Node getLeftNode() {
21         return leftNode;
22     }
23     public void setLeftNode(Node leftNode) {
 
24         this.leftNode = leftNode;
25     }
26     public Node getRightNode() {
27         return rightNode;
28     }
29     public void setRightNode(Node rightNode) {
30         this.rightNode = rightNode;
31     }
32 }

 1 /**
 2      * 初始化二叉樹
 3      * @return
 4      */
 5     public
 
 Node init() {
 6         Node I = new Node(8, null, null);
 7         Node H = new Node(4, null, null);
 8         Node G = new Node(2, null, null);
 9         Node F = new Node(7, null, I);
10         Node E = new Node(5, H, null);
11         Node D = new Node(1, null, G);
12         Node C = new Node(9, F, null);
13         Node B = new Node(3, D, E);
14         Node A = new Node(6, B, C);
15         //返回根節點
16         return A;
17     }

使用遞歸實現的鏡像對稱

 1 //鏡像對稱(遞歸實現)
 2     public void mirrorRecursively(Node root){
 3         if(root == null){ //沒有樹直接返回
 4             return;
 5         }
 6         if(root.getLeftNode() == null && root.getRightNode() == null){ //如果左右結點為空，也直接返回
 7             return;
 8         }
 9         Node pTemp = root.getLeftNode(); //交換樹的左右結點
10         root.setLeftNode(root.getRightNode());
11         root.setRightNode(pTemp);
12         if(root.getLeftNode()!=null){ //如果左結點不為空，繼續
13             mirrorRecursively(root.getLeftNode());
14         }
15         if(root.getRightNode() != null){ //如果右結點不為空，繼續
16             mirrorRecursively(root.getRightNode());
17         }
18     }

使用循環棧實現的鏡像對稱

 1 //鏡像對稱(循環棧實現)
 2     public void mirror2(Node root){
 3         if(root == null){ //沒有樹直接返回
 4             return;
 5         }
 6         Stack<Node> stack = new Stack<>();
 7         stack.push(root);
 8         while (!stack.isEmpty()){
 9             Node pop = stack.pop();
10             if (pop.getLeftNode() != null && pop.getRightNode() != null){
11                 Node pTemp = root.getLeftNode(); //交換樹的左右結點
12                 root.setLeftNode(root.getRightNode());
13                 root.setRightNode(pTemp);
14             }
15             if(root.getLeftNode()!=null){ //如果左結點不為空，壓入棧
16                 stack.push(root.getLeftNode());
17             }
18             if(root.getRightNode() != null){ //如果右結點不為空，壓入棧
19                 stack.push(root.getRightNode());
20             }
21         }
22     }

二叉樹的鏡像對稱實現方式(遞歸和循環棧)