1. 层序遍历

1.1 递归方式

public List<List<Integer>> resList = new ArrayList<List<Integer>>();

public List<List<Integer>> levelOrder(TreeNode root) {
    //checkFun01(root,0);
    checkFun02(root);

    return resList;
}

//DFS--递归方式
public void checkFun01(TreeNode node, Integer deep) {
    if (node == null) {
        return;
    }
    deep++;
    //若resList中的子list数小于deep，那么就在resList中添加一个子list
    if (resList.size() < deep) {
        ArrayList<Integer> integers = new ArrayList<>();
        resList.add(integers);
    }
    //将当前结点放入目前所在的层级中
    resList.get(deep - 1).add(node.val);
    checkFun01(node.left, deep);
    checkFun01(node.right, deep);
}

1.2 迭代方式--借助队列

public void checkFun02(TreeNode node) {
    if (node == null) {
        return;
    }
    Queue<TreeNode> que = new LinkedList<TreeNode>();
    que.offer(node);

    while (!que.isEmpty()) {
        List<Integer> itemList = new ArrayList<Integer>();
        int len = que.size();

        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);
    }
}

2. 翻转二叉树

//递归法-前序遍历（中左右）
public TreeNode invertTree(TreeNode root) {
    if (root == null) {
        return null;
    }
    //node指当前结点
    TreeNode node = root;
    //交换当前结点的左右结点
    swapChildren(node);
    invertTree(node.left);
    invertTree(node.right);
    return root;
}

private void swapChildren(TreeNode node) {
    TreeNode tmp = node.right;
    node.right = node.left;
    node.left = tmp;
}

3. 对称二叉树

public boolean isSymmetric(TreeNode root) {
    return compare(root.left, root.right);
}
//将根节点的左右结点进行比较
public Boolean compare(TreeNode left, TreeNode right) {
    //左右结点一共有四种情况
    //    左             右    
    // 1：null         not null  
    // 2：not null     null  
    // 3：null         null  
    // 4：not null   not null  
    if (left == null && right != null) {
        return false;
    }
    if (left != null && right == null) {
        return false;
    }
    if (left == null && right == null) {
        return true;
    }
    //第四种情况是左右结点都不为null,对他们的val进行比较
    if (left.val != right.val) {
        return false;
    }
    //经过上述判断，当前将根节点的左右结点是相同的
    //开始进行递归比较，外侧与外侧比较，内侧与内侧比较
    Boolean outside = compare(left.left, right.right);
    Boolean inside = compare(left.right, right.left);
    return outside && inside;
}