16-lt-对称二叉树

101.对称二叉树

思路：

对于二叉树的操作，一般都是二叉树遍历的操作，此处求得对称二叉树，上来首先想到的是对称二叉树，但是写出来之后，对于null处理不好处理，进行了null值处理之后，仍然不行；忘记了观察规律，二叉树的对称树，实际上就是左子树和右子树的一个比较。

 

遇到问题：

思路想歪了，只停留在算法层面上，忘记考虑真实的解题思路。

结果：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        return check(root,root);
    }

    public boolean check(TreeNode u,TreeNode v){
        Queue<TreeNode> queue = new LinkedList<>();

        queue.offer(u);
        queue.offer(v);

        while(!queue.isEmpty()){
            
             u = queue.poll();
             v = queue.poll();
            if(u==null && v==null){
                continue;
            }
            if(u==null || v==null || u.val != v.val){
                return false;
            }

            queue.offer(u.left);
            queue.offer(v.right);

            queue.offer(v.left);
            queue.offer(u.right);
        }
        return true;


    }
    
}

错误思路：

 public static boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return false;
        }
        //BFS stack进行遍历
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        Stack<Integer> stack = new Stack<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode poll = queue.poll();
                if (!stack.isEmpty() && stack.peek() == poll.val) {
                    stack.pop();
                } else {
                    stack.push(poll.val);
                }
                //空的treenode进行替换
                if (poll.left != null) {
                    queue.offer(poll.left);
                }
                if (poll.right != null) {
                    queue.offer(poll.right);
                }
            }
        }
        if (stack.size() == 1 && stack.peek() == root.val) {
            return true;
        } else {
            return false;
        }
    }

总结：

当算法不能够解决问题时，要多想一下解决事情的本质；算法只是给你提供一个思路而不是解法。

加油！！