15-算法训练营第十五天 |力扣102二叉树的层序遍历、力扣226翻转二叉树、力扣101对称二叉树

力扣102：二叉树的层序遍历

题目链接:力扣102：二叉树的层序遍历

---

思路：

1.定义一个集合，用于接收结果
2.校验参数，参数为空直接返回空集合
3.定义一个队列，用于记录每一层的元素，并将根节点加入到队列中
4.循环遍历队列中的元素，记录每层元素的大小
5.根据每层元素的大小，来弹出队列中的元素添加到结果集中，弹出的同时并把该元素的左右节点添加到队列中

---

代码：

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        // 1.定义一个集合，用于接收结果
        List<List<Integer>> result = new ArrayList<>();
        // 2.校验参数
        if (root == null) {
            return result;
        }

        // 3.定义一个队列，用于记录每一层的元素，并将根节点加入到队列中
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        // 4.循环遍历队列中的元素，记录每层元素的大小
        while (!queue.isEmpty()) {
            int size = queue.size();
            // 5.根据每层元素的大小，来弹出队列中的元素添加到结果集中，弹出的同时并把该元素的左右节点添加到队列中
            List<Integer> levelResult = new ArrayList<>();
            while (size > 0) {
                TreeNode top = queue.poll();
                levelResult.add(top.val);
                if (top.left != null) {
                    queue.add(top.left);
                }
                if (top.right != null) {
                    queue.add(top.right);
                }
                size--;
            }
            result.add(levelResult);
        }

        return result;
    }

}

---

力扣226：翻转二叉树

题目链接:力扣226：翻转二叉树

---

思路：

采用两种方法，分别是深度优先遍历和广度优先遍历
一、深度优先遍历：
1.确定递归参数
2.确定递归终止条件
3.书写每层递归逻辑
4.翻转当前节点的左右节点
5.递归翻转当前节点的左节点
6.递归翻转当前节点的右节点

二、广度优先遍历：
1.校验参数
2.定义一个队列，用于接收每层的元素，并将根节点添加到队列中
3.循环遍历队列中的元素，根据队列中每层元素的大小进行遍历
4.弹出队列元素，并交换当前元素的左右节点
5.将当前元素的左右节点添加到队列中

---

代码：

class Solution {
    // 深度优先遍历
    public TreeNode invertTree(TreeNode root) {
        // 1.确定递归参数
        // 2.确定递归终止条件
        if (root == null) {
            return root;
        }
        // 3.书写每层递归逻辑
        // 4.翻转当前节点的左右节点
        swap(root);
        // 5.递归翻转当前节点的左节点
        if (root.left != null) {
            invertTree(root.left);
        }
        // 6.递归翻转当前节点的右节点
        if (root.right != null) {
            invertTree(root.right);
        }
        
        return root;
    }
    
    private void swap(TreeNode root) {
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }

	class Solution {
    // 广度优先遍历
    public TreeNode invertTree(TreeNode root) {
        // 1.校验参数
        if (root == null) {
            return root;
        }
        // 2.定义一个队列，用于接收每层的元素，并将根节点添加到队列中
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        // 3.循环遍历队列中的元素，根据队列中每层元素的大小进行遍历
        while (!queue.isEmpty()) {
            int size = queue.size();
            while (size > 0) {
                // 4.弹出队列元素，并交换当前元素的左右节点
                TreeNode top = queue.poll();
                swap(top);
                // 5.将当前元素的左右节点添加到队列中
                if (top.left != null) {
                    queue.offer(top.left);
                }
                if (top.right != null) {
                    queue.offer(top.right);
                }
                size--;
            }
        }
        
        return root;
    }
    
    private void swap(TreeNode root) {
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }
}

}

---

力扣101：对称二叉树

题目链接:力扣101：对称二叉树

---

思路：

0.校验参数
1.确定递归参数
2.确定递归终止条件（列举左右节点的所有情况）
/**
左 右
空 空
空 不为空
不为空 空
值不等 值不等
值相等 值相等
*/
3.确定递归单层逻辑（左节点和右节点值相等，那么就分别比较外侧子节点和内侧子节点）

---

代码：

/**
 * 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 boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }
        
        return compare(root.left, root.right);
    }

    // 1.确定递归参数
    private boolean compare(TreeNode left, TreeNode right) {
        /**
            左           右
            空           空
            空          不为空
            不为空        空
            值不等      值不等
            值相等      值相等
         */
         // 2.确定递归终止条件
        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;
         }

        // 3.确定递归单层逻辑
        // 左节点和右节点值相等，那么就分别比较外侧子节点和内侧子节点
         boolean outside = compare(left.left, right.right);
         boolean inside = compare(left.right, right.left);

         return outside && inside;
    }
}

---