算法刷题打卡（十三）

91 解码方法

91. 解码方法 - 力扣（LeetCode） (leetcode-cn.com)

一条包含字母 A-Z 的消息通过以下映射进行了 编码 ：

‘A’ -> 1
‘B’ -> 2
…
‘Z’ -> 26
要 解码 已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。例如，“11106” 可以映射为：

“AAJF” ，将消息分组为 (1 1 10 6)
“KJF” ，将消息分组为 (11 10 6)
注意，消息不能分组为 (1 11 06) ，因为 “06” 不能映射为 “F” ，这是由于 “6” 和 “06” 在映射中并不等价。

给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。

题目数据保证答案肯定是一个 32 位 的整数。

示例 1：

输入：s = “12”
输出：2
解释：它可以解码为 “AB”（1 2）或者 “L”（12）。
示例 2：

输入：s = “226”
输出：3
解释：它可以解码为 “BZ” (2 26), “VF” (22 6), 或者 “BBF” (2 2 6) 。
示例 3：

输入：s = “0”
输出：0
解释：没有字符映射到以 0 开头的数字。
含有 0 的有效映射是 ‘J’ -> “10” 和 ‘T’-> “20” 。
由于没有字符，因此没有有效的方法对此进行解码，因为所有数字都需要映射。
示例 4：

输入：s = “06”
输出：0
解释：“06” 不能映射到 “F” ，因为字符串含有前导 0（“6” 和 “06” 在映射中并不等价）。

	//动态规划	
    public static int numDecodings(String s) {
        if(s == null || s.length() == 0){
            return 0;
        }
        int N = s.length();
        int[] dp = new int[N + 1];
        dp[N] = 1;
        for(int i = N - 1; i >= 0; i--){
            if(s.charAt(i) != '0'){
                dp[i] = dp[i + 1];
                if(i + 1 == N){
                    continue;
                }
                if( (s.charAt(i) - '0' )* 10 + s.charAt(i + 1) -'0' <= 26 ){
                    dp[i] += dp[i + 2];
                }
            }
        }
        return dp[0];
    }

94 二叉树的中序遍历

94. 二叉树的中序遍历 - 力扣（LeetCode） (leetcode-cn.com)

给定一个二叉树的根节点 root ，返回它的 中序 遍历。

示例 1：

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

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

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

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

输入：root = [1,null,2]
输出：[1,2]

    //递归
	public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        in(root,ans);
        return ans;
    }
    public static void in(TreeNode node,List<Integer> ans){
        if(node == null){
            return;
        }
        in(node.left,ans);
        ans.add(node.val);
        in(node.right,ans);
    }
	//Morris 遍历
	public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        if (root == null) {
            return ans;
        }
        TreeNode mostRight = null;//最右节点
        while (root != null) {
			if(root.left != null){
			    mostRight = root.left;
			    while (mostRight.right != null && mostRight.right != root){//找到左子树最右节点
			        mostRight = mostRight.right;
                }
			    if (mostRight.right == null){//连上 root节点
			        mostRight.right = root;
                    root = root.left; //向左走
                    continue;
                }else {
			        mostRight.right = null;
                }
            }
			ans.add(root.val);
            root = root.right;
        }
        return ans;
    }

98 验证二叉搜索树

98. 验证二叉搜索树 - 力扣（LeetCode） (leetcode-cn.com)

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

节点的左子树只包含 小于 当前节点的数。
节点的右子树只包含 大于 当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

示例 1：

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

输入：root = [5,1,4,null,null,3,6]
输出：false
解释：根节点的值是 5 ，但是右子节点的值是 4 。

//中序遍历  看值
    public boolean isValidBST(TreeNode root) {
        return inIsBST(root,Long.MIN_VALUE,Long.MAX_VALUE);
    }
    public static boolean inIsBST(TreeNode node,long min,long max){
        if(node == null){
            return true;
        }
        if(node.val <= min || node.val >= max){
            return false;
        }
        return  inIsBST(node.left,min,node.val) && inIsBST(node.right,node.val,max); 
    }

101 对称二叉树

101. 对称二叉树 - 力扣（LeetCode） (leetcode-cn.com)

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

	1
   / \
  2   2
 / \ / \
3  4 4  3

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

	1
   / \
  2   2
   \   \
   3    3

//中轴对称	
    public boolean isSymmetric(TreeNode root) {
        return symmetry(root,root);
    }
    public static boolean symmetry(TreeNode h1, TreeNode h2){
		if (h1 == null && h2 == null){
			return true;
		}
		if (h1 != null && h2!= null){
			return h1.val == h2.val && symmetry(h1.left,h2.right)&&symmetry(h1.right,h2.left);
		}
		return false;
	}