7.3 二叉树的层序遍历

https://leetcode-cn.com/problems/binary-tree-level-order-traversal/102.
先定义一个存放最终结果的ArrayList为res，然后定义一个队列存放节点，while循环中，队列不为空，那么就for往一个数组里面放每一层的结果,然后再往队列里加入节点的left和right，然后循环。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res=new ArrayList<List<Integer>>();
        if(root==null) return res;
        Queue<TreeNode> q1=new LinkedList<TreeNode>();
        q1.offer(root);
        while(!q1.isEmpty()){
            List<Integer> ans=new ArrayList<Integer>();
            int currentsize=q1.size();
            for(int i=0;i<currentsize;i++){
                TreeNode node= q1.poll();
                ans.add(node.val);
                if(node.left!=null){
                    q1.offer(node.left);
                }
                if(node.right!=null){
                    q1.offer(node.right);
                }
            }
            res.add(ans);
        }
        return res;
    }
}

最长递增子序列

用dp，dp[i]的值表示nums[i]结尾最长递增子序列的数，把dp数组的所有值初始化为1，用两个for循环，第一层i遍历nums数组，第二层用j，j每次发现一个递增的数，dp就加1，和原来的大小相比。i循环的话每次往后1，所以每次发现一个递增的数，就能加1.

class Solution {
    public int lengthOfLIS(int[] nums) {
        int n =nums.length;
        int res=0;
        int dp[]=new int [n];
        Arrays.fill(dp,1);
        for(int i=0;i<n;i++){
            for(int j=0;j<i;j++){
                if(nums[j]<nums[i]) dp[i]=Math.max(dp[i],dp[j]+1);
            }
            res=Math.max(res,dp[i]);
        }
        return res;
    }
}

剑指 Offer 26. 树的子结构

class Solution {
    public boolean isSubStructure(TreeNode A, TreeNode B) {
        //这个函数对这棵树进行前序遍历：即处理根节点，再递归左子节点，再递归处理右子节点
        //特殊情况是：当A或B是空树的时候 返回false
        //用||关系可以达到 不同顺序遍历的作用
        if(A==null||B==null){
            return false;
        }
        return recur(A,B)||isSubStructure(A.left,B)||isSubStructure(A.right,B);
    }
    //此函数的作用是从上个函数得到的根节点开始递归比较 是否是子树
    boolean recur(TreeNode A, TreeNode B){
        //结束条件
        //当最后一层B已经为空的，证明则B中节点全是A中节点
        if(B==null){
            return true;
        }
        //这里因为有上一个条件，则说明 A已经为空了，B却不为空，则一定不是子数
        if(A==null){
            return false;
        }
        //处理本次递归，即处理当前节点
        if(A.val!=B.val){
            return false;
        }
        //递归，同时递归左右两个子节点
        return recur(A.left,B.left)&&recur(A.right,B.right);
    }
}