代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿

---

主要有两种方式，第一种是函数包含深度（层数变量）和根节点，第二种是函数只包含根节点；
包括深度的函数可以通过递归进行遍历；
只包含根节点的函数则需要用到while循环和堆栈保存每层的根节点进行遍历。

一、102. 二叉树的层序遍历—包含深度

public List<List<Integer>> levelOrder(TreeNode root) {
        checkFun01(root,0);
        return resList;
    }
List<List<Integer>> resList = new ArrayList<>();
public void checkFun01(TreeNode node, Integer deep){
	deep++;
	if(ndoe == null)
		return ;
	if(resList.size()<deep){
		List<Integer> item = new ArrayList<>();
		resList.add(item);
	}
	resList.get(deep-1).add(node.val);
	if(node.left!=null)
		checkFun01(node.left,deep);
	if(node.right!=null)
		checkFun01(node.right,deep);
	
}

二、二叉树的层序遍历 Ⅱ—参数只含有根节点

List<List<Integer>> resList = new ArrayList<>();
Deque<TreeNode> que = new LinkedList<>();
if(root == null){
	return resList;
}
que.offerLast(root);
while(!que.isEmpty()){
	List<Integer> levelList = new LinkedList<>();
	int levelSize = que.size();
	for(int i=0;i<levelSize;i++){
		TreeNode peek = que.pollFirst();
		levelList.add(peek.val);
		if(peek.left!=null){
			que.offerLast(peek.left);
		}
		if(peek.right!=null){
			que.offerLast(peek.right);
		}
	}
	resList.add(levelList)
}
List<List<Integer> reverseList = new ArrayList<>();
for(int i = resList.size()-1;i>=0;i--){
	reverseList.add(resList.get(i));
}
return reverseList;

---

三丶226. 反转二叉树

二叉树遍历三要素：
1. 确定参数和返回值
2. 确定结束条件
3. 确定单层递归逻辑

1. DFS 深度优先遍历

class Solution{
	public TreeNode invertTree(TreeNode root){
		if(root == null){
			return null;
		}
		invertTree(root.left);
		invertTree(root.right);
		swapChild(root);
		return root;
	}
	public void swapChild(TreeNode root){
		TreeNode tmp = root.left;
		root.left = root.right;
		root.right=tmp;
	}
}

2. BFS 广度优先遍历

class Solution {
    public TreeNode invertTree(TreeNode root) {
        Deque<TreeNode> que = new LinkedList<>();
        que.offer(root);
        if(root==null){
        	return null;
        }
        while(!que.isEmpty()){
            int levelSize = que.size();
            for(int i =0; i<levelSize;i++){
                TreeNode node = que.poll();
                if(node==null){
                    continue;
                }
                swap(node);
                if(node.left!=null){
                    que.offer(node.left);
                }
                if(node.right!=null){
                    que.offer(node.right);
                }
            }
        }
        return root;
    }
    public void swap(TreeNode root){
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;
    }
}

---

四丶101. 对称二叉树

1.

class Solution {
    public boolean isSymmetric(TreeNode root) {
        return compare(root.left,root.right);
    }
    public boolean compare(TreeNode left, TreeNode right){
        if(left==null && right == null){
            return true;
        }else if(left!=null && right ==null){
            return false;
        }else if(left==null && right!=null){
            return false;
        }else if(left.val != right.val){
            return false;
        }
        boolean compareOutside = compare(left.left,right.right);
        boolean compareInside = compare(left.right,right.left);
        return compareInside && compareOutside; 
    }
}