力扣刷题

1.叶子相似的树

请考虑一棵二叉树上所有的叶子，这些叶子的值按从左到右的顺序排列形成一个 叶值序列 。

举个例子，如上图所示，给定一棵叶值序列为 (6, 7, 4, 9, 8) 的树。

如果有两棵二叉树的叶值序列是相同，那么我们就认为它们是 叶相似 的。

如果给定的两个根结点分别为 root1 和 root2 的树是叶相似的，则返回 true；否则返回 false 。

输入：root1 = [3,5,1,6,2,9,8,null,null,7,4], root2 = [3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]
输出：true

(1)法一：采用中序遍历生成叶子结点的数组，进行对比。

/**
 * 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 {
    private Integer m=new Integer(0);
    private Integer n=new Integer(0);
    private int[] rootArray1=new int[200];
    private int[] rootArray2=new int[200];
    public boolean leafSimilar(TreeNode root1, TreeNode root2) {
        getLeafNode1(root1);
        getLeafNode2(root2);
        boolean result= true;
        if(m.equals(n)){
            for(int i=0;i<m;i++){
                if(rootArray1[i]==rootArray2[i]){
                    continue;
                }
                else{
                    result=false;
                    break;
                }
            }
        }
        else{
            result=false;
        }
        return result;
    }
    public void getLeafNode1(TreeNode root){
        if(root!=null){
            getLeafNode1(root.left);
            if(root.left==null&&root.right==null){
                rootArray1[m++]=root.val;
            }
            getLeafNode1(root.right);
        }
    }
    public void getLeafNode2(TreeNode root){
        if(root!=null){
            getLeafNode2(root.left);
            if(root.left==null&&root.right==null){
                rootArray2[n++]=root.val;
            }
            getLeafNode2(root.right);
        }
    }
}

（2）法二：递归法

1）二叉树的问题其实首先想的就是递归，在这里是为了得到所有叶子结点的排序数组，其实为了比较方便可以直接返回String的形式，但要注意每个数据后面都要加上一个“，”，以防止数据出现巧合现象。
2）在这里可以用分治的思想，求整个树的叶子结点序列等价于左子树叶子结点序列+右子树叶子结点序列，然后再找出递归终结的点即可，即root为null的时候和root为叶子结点的时候如何处理。

class Solution {
    public boolean leafSimilar(TreeNode root1, TreeNode root2) {
        String str=new String("");
        String strRoot1=getLeafArray(root1);
        String strRoot2=getLeafArray(root2);
        if(strRoot1.equals(strRoot2)){
            return true;
        }
        else{
            return false;
        }
    }
    public String getLeafArray(TreeNode root)    {
        if(root==null){
            return "";
        }
        if(root.left==null&&root.right==null){
            return ""+root.val+",";
        }
        return getLeafArray(root.left)+getLeafArray(root.right);
    }
}

2.判断子序列

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。
进阶：如果有大量输入的 S，称作 S1, S2, … , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

示例 1：
输入：s = “abc”, t = “ahbgdc”
输出：true

（1）法一：动态规划版：

设置二维数组，dp[i][j]表示字符串s的前i位与字符串t的前j位的匹配位数。
状态转换公式：dp[i][j]=max(dp[i][j-1]，dp[i-1][j-1]+(s[i]==t[j]))
但是对于这一题而言，这种做法并不简单，效率不高。

（2）法二：数组遍历版：

class Solution {
    public boolean isSubsequence(String s, String t) {
        int i,j;
        for(i=0,j=0;i<s.length()&&j<t.length();)         {
            if(s.charAt(i)==t.charAt(j)){
                i++;
                j++;
            }
            else{
                j++;
            }
        }
        if(i<s.length()){
            return false;
        }
        else{
            return true;
        }
    }
}

（3）要充分利用已有的函数啊！！！

class Solution {
    public boolean isSubsequence(String s, String t) {
        int index=-1;
        for(char ch:s.toCharArray()){
            index=t.indexOf(ch,index+1);
            if(index==-1){
                return false;
            }
        }
        return true;
    }
}