【剑指offer-58】20190909/01 对称的二叉树

【剑指offer-58】对称的二叉树

• 考点：树
• 时间限制：1秒
• 空间限制：32768K
• 请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

---

思路：

• 首先根节点以及其左右子树，左子树的左子树和右子树的右子树相同
• 左子树的右子树和右子树的左子树相同即可，采用递归
• 非递归也可，采用栈或队列存取各级子树根节点

代码：

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    boolean isSymmetrical(TreeNode pRoot)
    {
        if (pRoot == null) {
            return true;
        }
        return isSymmetrical(pRoot.left, pRoot.right);
    }
    private boolean isSymmetrical(TreeNode left, TreeNode right) {
        if (left == null && right == null) {
            return true;
        }
        // 一边为空 一边不为空
        if (left == null || right == null) {
            return false;
        }
        // 当前节点值相等 左节点的左孩子==右节点的右孩子 左节点的右孩子==右节点的左孩子 （对称）
        return left.val == right.val && isSymmetrical(left.left, right.right) && isSymmetrical(left.right, right.left);
    }
}

我的问题：

树的这种遍历一般用递归做法比较容易理解。
这个是判断是否对称。对称就是左节点的左孩子，等于右节点的右孩子，右节点的左孩子等于左节点的右孩子。递归判断即可

---

其他思路1：

非递归算法，利用DFS和BFS

DFS：

• DFS使用stack来保存成对的节点
• 1.出栈的时候也是成对成对的 ，
  1.若都为空，继续；
  2.一个为空，返回false;
  3.不为空，比较当前值，值不等，返回false；
• 2.确定入栈顺序，每次入栈都是成对成对的，如left.left， right.right ;left.rigth,right.left

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
import java.util.Stack;
public class Solution {
    boolean isSymmetrical(TreeNode pRoot)
    {
        if (pRoot == null) {
            return true;
        }
        Stack<TreeNode> stack = new Stack();
        stack.push(pRoot.left);
        stack.push(pRoot.right);
        
        while (!stack.isEmpty()) {
            // 成对取出
            TreeNode right = stack.pop(); 
            TreeNode left = stack.pop();
            if (left == null && right == null) {
                continue;
            }
            if (left == null || right == null) {
                return false;
            }
            if (left.val != right.val) {
                return false;
            }
            
            // 成对放入
            stack.push(left.left);
            stack.push(right.right);
            stack.push(left.right);
            stack.push(right.left);
        }
        return true;
    }
}

---

其他思路2：

BFS使用Queue来保存成对的节点，代码和上面极其相似

• 1.出队的时候也是成对成对的
  1.若都为空，继续；
  2.一个为空，返回false;
  3.不为空，比较当前值，值不等，返回false；
• 2.确定入队顺序，每次入队都是成对成对的，如left.left， right.right ;left.rigth,right.left

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
import java.util.Queue;
import java.util.LinkedList;

public class Solution {
    boolean isSymmetrical(TreeNode pRoot)
    {
        if (pRoot == null) {
            return true;
        }
        Queue<TreeNode> queue = new LinkedList();
        queue.offer(pRoot.left);
        queue.offer(pRoot.right);
        
        while(!queue.isEmpty()) {
            TreeNode left = queue.poll();
            TreeNode right = queue.poll();
            
            if (left == null && right == null) {
                continue;
            }
            if (left == null || right == null) {
                return false;
            }
            if (left.val != right.val) {
                return false;
            }
            
            queue.offer(left.left);
            queue.offer(right.right);
            queue.offer(left.right);
            queue.offer(right.left);
        }
        return true;
    }
}

---