LeetCode 144二叉树的前序遍历、102二叉树的层序遍历（广度优先）、103二叉树的锯齿形层状遍历、114二叉树展开为链表、139单词拆分（动态规划）

Top1：LeetCode 144二叉树的前序遍历

题目描述：
给你二叉树的根节点 root ，返回它节点值的 前序 遍历。
示例1：
输入：root = [1,null,2,3]
输出：[1,2,3]

示例 2：
输入：root = []
输出：[]

一、按照访问根节点——左子树——右子树的方式遍历这棵树，而在访问左子树或者右子树的时候，我们按照同样的方式遍历，直到遍历完整棵树。

可通过完整代码：

public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> ans = new ArrayList<>();
    preorder(root, ans);
    return ans;
}

private void preorder(TreeNode root, List<Integer> ans) {
    if (root == null) {
        return;
    }
    ans.add(root.val);
    preorder(root.left, ans);
    preorder(root.right, ans);
}

Top2：LeetCode 102二叉树的层序遍历（广度优先）

题目描述：
给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。
示例1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：
输入：root = [1]
输出：[[1]]

示例 3：
输入：root = []
输出：[]

一、广度优先搜索：建立一个ans的List<List> ans，之后新建队列Queue<TreeNode> queue = new LinkedList<>();，while循环添加答案，并通过队列长度遍历添加sub.add(node.val)，判断left和right非null添加到队列中

记树上的所有节点数为n

• 时间复杂度：每个节点都要进出队列一次，所以为O（n）
• 空间复杂度：队列中的元素不超过n个，所以为O（n）

可通过完整代码：

public List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> ans = new ArrayList<>();
    if (root == null) return ans;

    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    while (!queue.isEmpty()) {
        List<Integer> sub = new ArrayList<>();
        int curLevelSize = queue.size();
        for (int i = 0; i < curLevelSize; i++) {
            TreeNode node = queue.poll();
            sub.add(node.val);   // 添加当前遍历queue的node值
            if (node.left != null) queue.offer(node.left);   // 添加左右的非空子树
            if (node.right != null) queue.offer(node.right);
        }
        ans.add(sub);
    }
    return ans;
}

Top3：Leetcode 103二叉树的锯齿形层状遍历

官方题解：https://leetcode.cn/problems/binary-tree-zigzag-level-order-traversal/solution/er-cha-shu-de-ju-chi-xing-ceng-xu-bian-l-qsun/
题目描述：给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
【先左–>右–>左】

一、其他的根据queue.size()进行for循环和层序遍历一样，但是LIst换成了Deque双端队列，顺序就从左往右加到Deque末尾，正好顺序：左–>。逆序就offerFirst

• 时间复杂度：O（n）。其中 N 为二叉树的节点数。每个节点会且仅会被遍历一次。
• 空间复杂度：O（n）。我们需要维护存储节点的队列和存储节点值的双端队列，空间复杂度为 O(N)。

可通过完整代码：

public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
    List<List<Integer>> ans = new ArrayList<>();
    if (root == null) return ans;
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    boolean isOrderLeft = true;   // 从左-->右扫描
    while (!queue.isEmpty()) {
        Deque<Integer> levelList = new LinkedList<>();
        int size = queue.size();
        for (int i = 0; i < size; i++) {
            TreeNode node = queue.poll();   // 即弹出了元素，有可以接到弹出的元素TreeNode
            if (isOrderLeft) levelList.offerLast(node.val);   // 本身queue是左，右遍历的。所以加到双端队列末尾相当于把left往左挤
            else levelList.offerFirst(node.val);   // 加到头部相当于把left往右挤
            if (node.left != null) queue.offer(node.left);
            if (node.right != null) queue.offer(node.right);
        }
        ans.add(new LinkedList<>(levelList));   // new LinkedList也可以加入List<Integer>
        isOrderLeft = !isOrderLeft;
    }
    return ans;
}

Top4：LeetCode 114二叉树展开为链表

题目描述：
给你二叉树的根结点 root ，请你将它展开为一个单链表：
展开后的单链表应该同样使用 TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null 。
展开后的单链表应该与二叉树 先序遍历 顺序相同。

示例1：

输入：root = [1,2,5,3,4,null,6]
输出：[1,null,2,null,3,null,4,null,5,null,6]

示例 2：
输入：root = []
输出：[]

一、首先通过当前根节点找到cur左子树前序的最后一个右节点predecessor，将此节点和右子树连接起来；伸展【将curr.left=null；curr.right=next】next就是cur.left；然后继续循环往左遍历，连接，遍历到最后总会伸展完

• 时间复杂度：O(n)。其中 n 是二叉树的节点数。展开为单链表的过程中，需要对每个节点访问一次，在寻找前驱节点的过程中，每个节点最多被额外访问一次。
• 空间复杂度：O(1)

可通过完整代码：

public void flatten(TreeNode root) {
    TreeNode curr = root;
    while (curr != null) {
        if (curr.left != null) {
            TreeNode next = curr.left;
            TreeNode predecessor = next;
            while (predecessor.right != null) {   // 找到cur左子树的前序最后一个节点
                predecessor = predecessor.right;
            }
            predecessor.right = curr.right;   // 连接cur子树前序的最后一个节点和右子树
            curr.left = null;   // 部分伸展
            curr.right = next;
        }
        curr = curr.right;   // cur.right也即是原来cur的左节点，之后继续往左遍历，连接左子树最右边节点和其它部分【遍历到最后总会伸展完】
    }
}

Top5：LeetCode 139单词拆分（动态规划）

题目描述：
给你一个字符串 s 和一个字符串列表 wordDict 作为字典。请你判断是否可以利用字典中出现的单词拼接出 s 。

注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。

一、我们定义dp[i]表示字符串 s 前 i 个字符组成的字符串 s[0…i-1]是否能被空格拆分成若干个字典中出现的单词。状态转移方程：

if (dp[j] && set.contains(s.substring(j, i))) {   // 下标j 到 i-1

• 时间复杂度：其中 n 为字符串 s 的长度。我们一共有 O(n) 个状态需要计算，每次计算需要枚举 O(n) 个分割点，哈希表判断一个字符串是否出现在给定的字符串列表需要 O(1) 的时间，因此总时间复杂度为 O(n 2 )。
• 空间复杂度：其中 n 为字符串 s 的长度。我们需要 O(n) 的空间存放dp值以及哈希表亦需要 O(n) 的空间复杂度，因此总空间复杂度为 O(n)。

可通过完整代码：

public boolean wordBreak(String s, List<String> wordDict) {
    Set<String> set = new HashSet(wordDict);
    boolean[] dp = new boolean[s.length() + 1];
    dp[0] = true;
    for (int i = 1; i <= s.length(); i++) {   // 填充dp[i]，从第一个开始dp[1]
        for (int j = 0; j < i; j++) {
            if (dp[j] && set.contains(s.substring(j, i))) {   // 下标j 到 i-1
                dp[i] = true;
                break;
            }
        }
    }
    return dp[s.length()];   // dp[s.length()]为最后一个
}