✿LeetCode102.二叉树的层序遍历❀

链接：102.二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。（即逐层地，从左到右访问所有节点）。

二叉树的层序遍历是广度优先遍历，前中后序遍历是深度优先遍历，层序遍历是用队列来操作的，代码如下：

java">public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result=new ArrayList<>();
        if(root==null){
            return result;
        }
        Queue<TreeNode> qu=new LinkedList<>();
        qu.offer(root);
        while(!qu.isEmpty()){
            List<Integer> list=new ArrayList<>();
            int size=qu.size();
            while(!qu.isEmpty() && size>0){
                TreeNode node=qu.poll();
                list.add(node.val);
                if(node.left!=null){
                    qu.offer(node.left);
                }
                if(node.right!=null){
                    qu.offer(node.right);
                }
                size--;
            }
            result.add(list);    
        }
        return result;
    }

✿LeetCode226.翻转二叉树❀

链接：226.翻转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

这道题有三种解法，分别是递归遍历、广度优先遍历、深度优先遍历，代码如下：

java">public TreeNode invertTree(TreeNode root) {
        // 递归法
        if(root==null){
            return null;
        }
        
        TreeNode temp=invertTree(root.left);
        root.left=invertTree(root.right);
        root.right=temp;
        return root;
    }

java">public TreeNode invertTree(TreeNode root) {
        if(root==null){
            return null;
        }
        
    //    深度优先遍历
        Stack<TreeNode> st=new Stack<>();
        st.push(root);
        while(!st.isEmpty()){
            TreeNode node=st.pop();
            TreeNode temp=node.left;
            node.left=node.right;
            node.right=temp;
            if(node.right!=null){
                st.push(node.right);
            }
            if(node.left!=null){
                st.push(node.left);
            }
        }
        return root;
    }

java">public TreeNode invertTree(TreeNode root) {
        if(root==null){
            return null;
        }
        // 广度优先遍历
        Queue<TreeNode> qu=new LinkedList<>();
        qu.add(root);
        while(!qu.isEmpty()){
           
            int size=qu.size();
            while(!qu.isEmpty() && size>0){
                TreeNode node=qu.poll();
                TreeNode temp=node.left;
                node.left=node.right;
                node.right=temp;
                if(node.left!=null){
                    qu.add(node.left);
                }
                if(node.right!=null){
                    qu.add(node.right);
                }
                size--;
            }
        }
        return root;

    }

✿LeetCode101.对称二叉树❀

链接：101.对称二叉树

给你一个二叉树的根节点 root ，检查它是否轴对称。

这道题的重点就是要分类讨论，代码如下：

java">public boolean isSymmetric(TreeNode root) {
        // 树中节点数目在范围 [1, 1000] 内
        return compare(root.left,root.right);
    }
    public boolean compare(TreeNode left,TreeNode right){
        if(left==null && right !=null){
            return false;
        }else if(left!=null && right==null){
            return false;
        }else if(left==null && right==null){
            return true;
        }else{
            if(left.val!=right.val){
                return false;
            }
        }
        boolean outside=compare(left.left,right.right);
        boolean inside=compare(left.right,right.left);
        return outside && inside;
    }