竞赛03. 重复的彩灯树

这个题有bug，最后输出的list不要求顺序，是乱序的，有点无语，导致测试没完全通过

思路：

1、想找到最小的节点，判断他们是否重复，重复的为新的子节点，找到他们的父节点

2、继续上一步判断，从子节点到父节点找

题目-03. 重复的彩灯树

我的提交返回竞赛

 

• 通过的用户数303
• 尝试过的用户数343
• 用户总通过次数311
• 用户总提交次数680
• 题目难度Medium

有一棵结构为二叉树的圣诞树 root 挂满了彩灯，各节点值表示彩灯的颜色。

如果两棵子树具有 相同的结构 和 相同的彩灯颜色分布，则它们是 重复 的。

请返回这棵树上所有 重复的子树。

注意：

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

• 树中的结点数在[1,6000]范围内。
• -200 <= Node.val <= 200

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {TreeNode[]}
 */
var lightDistribution = function(root) {
    function isEqual(node1,node2){
        if(node1===null&&node2===null){
            return true
        }else if(node1===null){
            return false
        }else if(node2===null){
            return false
        }
        return node1.val===node2.val&&isEqual(node1.left,node2.left)&&isEqual(node1.right,node2.right)
    }
    let preList=[]
    const parentArr=[]
    const nlist=[root]
    let n=0;
    while(n<nlist.length){
      
        const node=nlist[n]
        if(node.left!==null){
            parentArr[nlist.length]=n
           nlist.push(node.left)
       }
        if(node.right!==null){
            parentArr[nlist.length]=n
             nlist.push(node.right)
        }
        if(node.left===null&&node.right===null){
           preList.push(n)
        }
       n++
   }
    const cArr=[]
    while(preList.length>1){
        const list=[]
        
        for(let i=0;i<preList.length;i++){
            const node=nlist[preList[i]]
            for(let j=i+1;j<preList.length;j++){
                if(isEqual(node,nlist[preList[j]])){
                    if(list.indexOf(preList[i])===-1){
                        list.push(preList[i])
                        cArr.unshift(preList[i])
                    }
                    list.push(preList[j])
                    preList.splice(j,1)
                }
            }
        }
        //得出重复节点的list
        const pList=[]
        for(let i=0;i<list.length;i++){
            const pn=parentArr[list[i]]
            if(pList.indexOf(pn)===-1){
                 pList.push(pn)
            }
        }
        console.log(cArr)
        preList=pList
    }
    
    return cArr.map((a)=>nlist[a])
    
};