代码随想录打卡DAY14

第一题

总之就是先判断是否为空，然后先把根节点加入队列进去，queue可以用linkedlist实现，在队列非空时候然后得到que的size，写一个for循环len长度次数，每次poll一个节点为tmpnode然后把左右节点都加入进去。

/**
 * 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 List<List<Integer>> resList = new ArrayList<List<Integer>>();


    public List<List<Integer>> levelOrder(TreeNode root) {
        sequenceTraversal(root);
        return resList;
    }
    public void sequenceTraversal(TreeNode root){
        if(root == null){
            return ;
        }
        Queue <TreeNode> que=new LinkedList<>();
        que.offer(root);
        while(!que.isEmpty()){
            int len=que.size();
            List<Integer> itemList=new ArrayList<>();

            while(len>0){
                TreeNode tmpNode=que.poll();
                itemList.add(tmpNode.val);

                if(tmpNode.left!=null){
                    que.offer(tmpNode.left);
                }

                if(tmpNode.right!=null){
                    que.offer(tmpNode.right);
                }
                
                len--;
            }
            resList.add(itemList);
        }

    }
}

翻转二叉树

翻转二叉树和层数遍历唯一的不同就是取出队首节点后交换左右子节点
 

class Solution {
    public TreeNode invertTree(TreeNode root) {
        // 如果根节点为空，则直接返回null
        if(root==null){
            return null;
        }
        // 交换根节点的左右子节点
        swapchildren(root);
        // 递归翻转左子树
        invertTree(root.left);
        // 递归翻转右子树
        invertTree(root.right);

        // 返回翻转后的根节点
        return root;

    }

    // 交换节点的左右子节点
    private void swapchildren(TreeNode node) {
        if (node == null) {
            return;
        }
        TreeNode temp = node.left;
        node.left = node.right;
        node.right = temp;
    }

}
class Solution {
    public TreeNode invertTree(TreeNode root) {
        // 如果根节点为空，则直接返回空
        if(root==null){
            return null;
        }
        // 创建一个队列用于存储待处理的节点
        Queue<TreeNode> que=new LinkedList<>();
        // 将根节点加入队列
        que.offer(root);
        // 当队列不为空时，循环处理队列中的节点
        while(!que.isEmpty()){
            // 获取当前层级的节点数量
            int len=que.size();
            // 遍历当前层级的所有节点
            for(int i=0;i<len;i++){
                // 取出队首节点
                TreeNode tmpNode=que.poll();
                // 交换当前节点的左右子节点
                swapchildren(tmpNode);
                // 如果当前节点有左子节点，则将其加入队列
                if(tmpNode.left!=null){
                    que.offer(tmpNode.left);
                }
                // 如果当前节点有右子节点，则将其加入队列
                if(tmpNode.right!=null){
                    que.offer(tmpNode.right);
                }
            }
        }
        // 返回翻转后的根节点
        return root;    
    }

    // 交换节点的左右子节点
    private void swapchildren(TreeNode node) {
        // 交换节点的左右子节点
        TreeNode tmp=node.left;
        node.left=node.right;
        node.right=tmp;
    }
}

对称二叉树 

还是一种递归一种迭代迭代类似层序遍历，只不过从根节点的左右开始因为不需要比较根节点

然后一次offer两个，只有当左右两个都不为空且值相等的情况才继续判断把各自的左右节点加入队列

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root==null){
            return true;
        }
        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 out=compare(left.left,right.right);
        boolean in=compare(left.right,right.left);
        boolean result=in && out;
        return result;
            
        }
}
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root==null){
            return true;
        }
        Queue <TreeNode> que=new LinkedList<>();
        que.offer(root.left);
        que.offer(root.right);
        while(!que.isEmpty()){
            TreeNode leftNode=que.poll();
            TreeNode rightNode=que.poll();
            if(leftNode==null && rightNode == null){
                continue;
            }
            else if(leftNode==null && rightNode!=null){
                return false;
            }
            else if(leftNode!=null && rightNode==null){
                return false;
            }
            else if(leftNode.val!=rightNode.val){
                return false;
            }
            que.offer(leftNode.left);
            que.offer(rightNode.right);
            que.offer(leftNode.right);
            que.offer(rightNode.left);

        }
        return true;         
                
    }
}