JS：二叉树（3）——序列化二叉树、查找重复子树

根据题意，思考一个二叉树节点需要做什么，到底用什么遍历顺序就清楚了。

• 297.二叉树的序列化与反序列化
• 652.寻找重复的子树

297.二叉树的序列化与反序列化 （困难）

你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。

所谓的序列化不过就是把结构化的数据「打平」，其实就是在考察二叉树的遍历方式。

那么，反序列化过程也是一样，先确定根节点 root，然后遵循前序遍历的规则，递归生成左右子树即可：

前序遍历解法：

var serialize = function(root) {
    let list = []
    function flatten(root){
        if(root == null) {
            list.push('#')
            return
        }
        list.push(root.val)
        flatten(root.left)
        flatten(root.right)
    }
    flatten(root)
    return list.join()
};

var deserialize = function(data) {
    let list = data.split(',')
    function decode(list){
        if(list.length==0) return null
        let val = list.shift()
        if(val == '#') return null
        let root = new TreeNode(val - 0)

        root.left = decode(list)
        root.right = decode(list)
        return root
    }
    return decode(list)
};

后序遍历解法
序列化方法与前序遍历结构一样

var serialize = function(root) {
    let list = []
    function flatten(root){
        if(root == null) {
            list.push('#')
            return
        }
        // list.push(root.val)
        flatten(root.left)
        flatten(root.right)
        list.push(root.val)
    }
    flatten(root)
    return list.join()
};

难点在于，如何实现后序遍历的 反序列化方法

var deserialize = function(data) {
    let list = data.split(',')
    function decode(list){
        if(list.length==0) return null
        // 从后往前取出元素
        let val = list.pop()
        if(val == '#') return null
        let root = new TreeNode(val - 0)
        // 先构造右子树，后构造左子树
        root.right = decode(list)
        root.left = decode(list)
        return root
    }
    return decode(list)
};

中序遍历的方式行不通，因为无法实现反序列化方法 deserialize ：要想实现反序列方法，首先要构造 root 节点。

层级遍历解法
在反序列化的过程中是需要记录空指针 null 的

var serialize = function(root) {
    if (root == null) return "#" // 即使返回"", split函数的结果为[""],即有一个元素
    let queue = [root], list = []
    while(queue.length) {
        let node = queue.shift()
        if(node == null){
            list.push('#')
            continue
        }
        list.push(node.val)
        queue.push(node.left)
        queue.push(node.right)
    }
    return list.join()
};

可以看到，每一个非空节点都会对应两个子节点，那么反序列化的思路也是用队列进行层级遍历，同时用索引 i 记录对应子节点的位置：

var deserialize = function(data) {
    let list = data.split(',')
    if(list[0] == '#') return null
    let root = new TreeNode(list[0] - 0)
    let queue = [root], i = 1

    while(queue.length) {
        let node = queue.shift()
        let leftval = list[i++]
        if(leftval != '#') {
            node.left = new TreeNode(leftval - 0)
            queue.push(node.left)
        }
        let rightval = list[i++]
        if(rightval != '#') {
            node.right = new TreeNode(rightval - 0)
            queue.push(node.right)
        }
    }
    return root
};

三种方法的时间，时间是逆着，所以最慢是先序遍历解法

652. 寻找重复的子树 （中等）（fail）

给定一棵二叉树 root，返回所有重复的子树。

对于同一类的重复子树，你只需要返回其中任意一棵的根结点即可。

如果两棵树具有相同的结构和相同的结点值，则它们是重复的。

老套路，先思考，对于某一个节点，它应该做什么。
你需要知道以下两点：
1、以我为根的这棵二叉树（子树）长啥样？——使用「后序遍历」。
2、以其他节点为根的子树都长啥样？

第一步
描述一棵二叉树的模样呢？——通过拼接字符串的方式把二叉树序列化
要知道以自己为根的树长啥样，是不是得先知道我的左右子树长啥样，再加上自己，就构成了整棵子树的样子。

你完全可以按照前序或者中序的顺序拼接字符串，因为这里只是为了描述一棵二叉树的样子，什么顺序不重要。

第二步
借助一个外部数据结构，让每个节点把自己子树的序列化结果存进去，这样，对于每个节点，不就可以知道有没有其他节点的子树和自己重复了

let hash = null, res = [];
// 遍历的同时，存储当前子树, 查找重复子树
function traverse(root) {
    if(root == null) return '#'
    let left = traverse(root.left)
    let right = traverse(root.right)

    let encode = left + ',' + right + ',' + root.val
    
    if(hash.get(encode) == 1) {
        res.push(root)
    }
    hash.set(encode, (hash.get(encode) || 0) + 1) 
    return encode
}
var findDuplicateSubtrees = function(root) {
    hash = new Map(), res = [];
    traverse(root)
    return res
};