二叉树的镜像对称实现方式(递归和循环栈)

首先初始化一棵树

public class Node {
    //数据
    private int data;
    //左孩子
    private Node leftNode;
    //右孩子
    private Node rightNode;
    public Node(int data, Node leftNode, Node rightNode){
        this.data = data;
        this.leftNode = leftNode;
        this.rightNode = rightNode;
    }

    public int getData() {
        return data;
    }
    public void setData(int data) {
        this.data = data;
    }
    public Node getLeftNode() {
        return leftNode;
    }
    public void setLeftNode(Node leftNode) {
        this.leftNode = leftNode;
    }
    public Node getRightNode() {
        return rightNode;
    }
    public void setRightNode(Node rightNode) {
        this.rightNode = rightNode;
    }
}

/**
     * 初始化二叉树
     * @return
     */
    public Node init() {
        Node I = new Node(8, null, null);
        Node H = new Node(4, null, null);
        Node G = new Node(2, null, null);
        Node F = new Node(7, null, I);
        Node E = new Node(5, H, null);
        Node D = new Node(1, null, G);
        Node C = new Node(9, F, null);
        Node B = new Node(3, D, E);
        Node A = new Node(6, B, C);
        //返回根节点
        return A;
    }

使用递归实现的镜像对称

//镜像对称(递归实现)
    public void mirrorRecursively(Node root){
        if(root == null){ //没有树直接返回
            return;
        }
        if(root.getLeftNode() == null && root.getRightNode() == null){ //如果左右结点为空，也直接返回
            return;
        }
        Node pTemp = root.getLeftNode(); //交换树的左右结点
        root.setLeftNode(root.getRightNode());
        root.setRightNode(pTemp);
        if(root.getLeftNode()!=null){ //如果左结点不为空，继续
            mirrorRecursively(root.getLeftNode());
        }
        if(root.getRightNode() != null){ //如果右结点不为空，继续
            mirrorRecursively(root.getRightNode());
        }
    }

使用循环栈实现的镜像对称

//镜像对称(循环栈实现)
    public void mirror2(Node root){
        if(root == null){ //没有树直接返回
            return;
        }
        Stack<Node> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()){
            Node pop = stack.pop();
            if (pop.getLeftNode() != null && pop.getRightNode() != null){
                Node pTemp = root.getLeftNode(); //交换树的左右结点
                root.setLeftNode(root.getRightNode());
                root.setRightNode(pTemp);
            }
            if(root.getLeftNode()!=null){ //如果左结点不为空，压入栈
                stack.push(root.getLeftNode());
            }
            if(root.getRightNode() != null){ //如果右结点不为空，压入栈
                stack.push(root.getRightNode());
            }
        }
    }