LeetCode---二叉树（1）层序遍历

新手模板永远的神！
这一部分的前后序迭代法很久之前写过，emmmm。
LeetCode二叉树前后序遍历（栈实现迭代法）
这一章节主要是层序遍历，就是一套模板，然后好几个题可以通用！记载一下。

问题描述

代码如下

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
import  ssl
ssl._create_default_https_context = ssl._create_unverified_context

2.读入数据

代码如下（示例）：

class Solution {
    List<List<Integer>> list = new ArrayList<List<Integer>>();//存放所有的节点值,注意其输出为[[1],[2,3]]二维形式
    public List<List<Integer>> levelOrder(TreeNode root) {//BFS 迭代遍历
        level_Or(root);
        return list;
    }
    public void level_Or(TreeNode root){
//        Queue<TreeNode> que = new LinkedList<TreeNode>();//存放每一层的所有节点
        Deque<TreeNode> que = new LinkedList<TreeNode>();//这两种形式皆可
        if(root == null) return;
        que.offer(root);//从根节点开始层序遍历，先把根节点加上

        while(!que.isEmpty()){
            List<Integer> tempList = new ArrayList<Integer>();//存放每一层遍历的值，对应二维中的每一维
            int len = que.size();//判断每一层有多少节点
            while(len > 0){
                TreeNode temp = que.poll();
                tempList.add(temp.val);//存放好当前节点的值
                if(temp.left != null) que.offer(temp.left);//判断有没有左孩子节点，有就放进队列
                if(temp.right != null) que.offer(temp.right);
                len--;//这一层的节点数处理完成一个。
            }
            list.add(tempList);
        }

//          return list;
    }
}

求最大深度的粘一个代码，其他几题只要是层序遍历就差不多：

class Solution {
    public int maxDepth(TreeNode root) {
        Deque<TreeNode> que = new LinkedList<>();
        if(root == null) return 0;
        que.offer(root);
        int depth = 0;
        while(!que.isEmpty()){
            int len = que.size();
            for(int i = 0; i< len; i++){
                TreeNode temp = que.poll();
                if(temp.left != null) que.offer(temp.left);
                if(temp.right != null) que.offer(temp.right);
            }
            depth++;
        }
        return depth;
    }
}

226翻转二叉树的题，可以用深度优先遍历的前后序做，中序会出现部分节点重复的问题，也可以用层序遍历做，我用的递归做的，主要是复习一下递归的三要素：

class Solution {
    public TreeNode invertTree(TreeNode root) {//看到翻转二叉树，我想到的是最后翻转出来的还是树，最后返回root
//深度优先遍历（前后序）、层次遍历，这里采用递归吧
        //递归三部曲
        if(root == null) return root;
        swapTree(root);//2.确定回归逻辑,这个交换函数需要自己写
        invertTree(root.left);//1.确定递归函数的参数和返回值
        invertTree(root.right);
        return root;//3.终止条件
    }
    public void swapTree(TreeNode root){
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }
}