572. 另一棵树的子树

给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。

二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/subtree-of-another-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路及方法

递归解法，写一个辅助函数判断两棵树是否相等，然后在主函数进行递归运算。主函数返回两棵树是否相等或者左子树是否包含目标树或者右子树是否包含目标树。

/**
 * 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 {
    // 判断root的某一子树是否等于subRoot
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        if (root == null && subRoot == null) return true;
        if (root == null || subRoot == null) return false;
        
        return isSameTree(root, subRoot) || isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot);
    }
    
    // 判断两棵树是否相等
    public boolean isSameTree(TreeNode root1, TreeNode root2) {
        if (root1 == null && root2 == null) return true;
        if (root1 == null || root2 == null) return false;
        
        return root1.val == root2.val && isSameTree(root1.left, root2.left) && isSameTree(root1.right, root2.right);
    }
}

结果如下：

117. 填充每个节点的下一个右侧节点指针 II

给定一个二叉树

struct Node {
int val;
Node *left;
Node *right;
Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路及方法

采用层次遍历的方法，根节点入队，再出队。

说一下每一层需要注意的问题。每一层除第一个节点外，所有节点都要连接上一节点，所以用last来记录上一节点。每层循环出队，第一个节点值直接赋给上一节点，继续循环，先将当前出队节点连接上一节点，再将出队节点赋给上一节点。

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        if (root == null) return null;

        // 层次遍历
        Queue<Node> queue = new LinkedList<>();
        // 根节点入队
        queue.offer(root);

        while (!queue.isEmpty()) {
            int size = queue.size();
            Node last = null;
            // 同一层节点出队
            for (int i = 0; i < size; i++) {
                Node cur = queue.poll();
                // 连接两个节点
                if (i != 0) {
                    last.next = cur;
                }
                // 当前节点赋给上一节点
                last = cur;
                // 子结点入队
                if (cur.left != null) {
                    queue.offer(cur.left);
                }
                if (cur.right != null) {
                    queue.offer(cur.right);
                }
            }
        }
        
        return root;
    }
}

结果如下：

334. 递增的三元子序列

给你一个整数数组 nums ，判断这个数组中是否存在长度为 3 的递增子序列。

如果存在这样的三元组下标 (i, j, k) 且满足 i < j < k ，使得 nums[i] < nums[j] < nums[k] ，返回 true ；否则，返回 false 。

示例 1：

输入：nums = [1,2,3,4,5]
输出：true
解释：任何 i < j < k 的三元组都满足题意
示例 2：

输入：nums = [5,4,3,2,1]
输出：false
解释：不存在满足题意的三元组
示例 3：

输入：nums = [2,1,5,0,4,6]
输出：true
解释：三元组 (3, 4, 5) 满足题意，因为 nums[3] == 0 < nums[4] == 4 < nums[5] == 6

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/increasing-triplet-subsequence
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路及方法

先审题，题目所要求的i<j<k，且nums[i] < nums[j] < nums[k] ，并没有要求i、j、k是连续的，所以根据这个特性，就不能用滑动窗口的解法来解。

反过来想，如果存在一个最小值，最小值右边存在一个次小值，次小值右边只要存在一个比它大的数，就满足条件，否则不满足。

class Solution {
    public boolean increasingTriplet(int[] nums) {
        int n = nums.length;
        
        int first = Integer.MAX_VALUE, second = Integer.MAX_VALUE;
        // 遍历寻找最小值和次小值，如果存在一个比次小值大的数，return true
        for (int i : nums) {
            if (i <= first) {
                first = i;
            } else if (i <= second) {
                second = i;
            } else return true;
        }

        return false;
    }
}

结果如下：