Leetcode刷题331. 验证二叉树的前序序列化

序列化二叉树的一种方法是使用 前序遍历 。当我们遇到一个非空节点时，我们可以记录下这个节点的值。如果它是一个空节点，我们可以使用一个标记值记录，例如 #。

例如，上面的二叉树可以被序列化为字符串 "9,3,4,#,#,1,#,#,2,#,6,#,#"，其中 # 代表一个空节点。

给定一串以逗号分隔的序列，验证它是否是正确的二叉树的前序序列化。编写一个在不重构树的条件下的可行算法。

保证 每个以逗号分隔的字符或为一个整数或为一个表示 null 指针的 '#' 。

你可以认为输入格式总是有效的

例如它永远不会包含两个连续的逗号，比如 "1,,3" 。
注意：不允许重建树。

示例 1:

输入: preorder = "9,3,4,#,#,1,#,#,2,#,6,#,#"
输出: true

示例 2:

输入: preorder = "1,#"
输出: false

示例 3:

输入: preorder = "9,#,#,1"
输出: false
 

提示:

1 <= preorder.length <= 104
preorder 由以逗号 “，” 分隔的 [0,100] 范围内的整数和 “#” 组成

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

感谢大神Stefan Pochmann的详细解法2 lines Java using Regex和6 lines Python, 7 lines Java

class Solution {
    public boolean isValidSerialization(String preorder) {
//		return isValidSerializationI(preorder);
//		return isValidSerializationII(preorder);
//		return isValidSerializationIII(preorder);
		return isValidSerializationIIII(preorder);
	}

	//方法四：统计槽的数量
	//如果是不是 # 则会多出两个槽数量，否则只会占用一个槽；如果槽没有被占满或者槽不够用了，则返回false
	//时间复杂度O(N)，空间复杂度O(N)
	private boolean isValidSerializationIIII(String preorder) {
		if (preorder == null || preorder.length() == 0) {
			return false;
		}
		if (preorder.equals("#")) {
			return true;
		}
		String[] arr = preorder.split(",");
		if (arr[0].equals("#")) {
			return false;
		}
		//根节点不为#，说明存在两个叶子
		int leaves = 2;
		for (int i = 1; i < arr.length; i++) {
			//槽不够用，返回false
			if (leaves <= 0) {
				return false;
			}
			//不是#，说明是树，会多出两个槽
			if (!arr[i].equals("#")) {
				leaves += 2;
			}
			//不管是否为#，都会占用一个槽
			leaves--;
		}
		//判断槽是否占满，如果是则正确
		return leaves == 0;
	}

	//方法三：任何非空二叉树的叶子节点数都比度为2的非叶子节点数多1
	//时间复杂度O(N)，空间复杂度O(1)
	//假设二叉树的总节点数为N，则树枝数为N-1
	//二叉树节点分为3类：0度节点(叶子节点)没有树枝z，1度节点(不分叉)有一个树枝y，2度节点(分叉)两个树枝x
	//则可以得到下面方程：
	//x + y + z = N
	//2x + y = N - 1
	//从而可以得到 z = x + 1
	private boolean isValidSerializationIII(String preorder) {
		if (preorder == null || preorder.length() == 0) {
			return false;
		}
		int leaf = 0, nonLeaf = 0;
		for (String val : preorder.split(",")) {
			//遍历过程中，如果叶子节点的数量大于非叶子节点，则说明有根节点为空，直接返回false
			if (leaf > nonLeaf) {
				return false;
			}
			if (val.equals("#")) {
				leaf++;
			} else {
				nonLeaf++;
			}
		}
		return leaf == nonLeaf + 1;
	}

	//方法二：基于方法一使用正则表达式替换
	private boolean isValidSerializationII(String preorder) {
		if (preorder == null || preorder.length() == 0) {
			return false;
		}
		String s = preorder.replaceAll("\\d+,#,#", "#");
		return s.equals("#") || !s.equals(preorder) && isValidSerialization(s);
	}

	//方法一：使用栈模拟二叉树的前序遍历，先将元素不断压栈，如果遇到4,#,#这种，直接替换成# (将4,#,#出栈，然后入栈#)
	//如果字符串合法，最后的结果是栈只有一个#
	//时间复杂度O(N^2)，空间复杂度O(N)
	private boolean isValidSerializationI(String preorder) {
		if (preorder == null || preorder.length() == 0) {
			return false;
		}
		if (preorder.equals("#")) {
			return true;
		}
		String[] arr = preorder.split(",");
		Stack<String> stack = new Stack<>();
		int len = 0;
		for (String val : arr) {
			stack.push(val);
			len++;
			while (len >= 3
					&& stack.get(len - 1).equals("#")
					&& stack.get(len - 2).equals("#")
					&& !stack.get(len - 3).equals("#")) {
				stack.pop();
				stack.pop();
				stack.pop();
				stack.push("#");

				len = stack.size();
			}
		}
		return stack.size() == 1 && stack.peek().equals("#");
	}
}