力扣652

package com.itheima.controller;
import java.util.*;

public class leetcode652 {
    // 定义树节点
    static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        public TreeNode() {}
        public TreeNode(int val) {this.val = val;}
        public TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }

    static Map<String, Integer> map;
    static List<TreeNode> ans;

    // 每个子树序列化（前序遍历和后序遍历）的结果是唯一的
    public static List<TreeNode> findDuplicateSubtrees(TreeNode root) {
        map = new HashMap<>();
        ans = new ArrayList<>();
        collect(root);
        return ans;

    }

    public static String collect(TreeNode node) {
        if (node == null) return "#";   // 空树用“#”表示
        String serial = node.val + "," + collect(node.left) + "," + collect(node.right);    // 递归
        map.put(serial, map.getOrDefault(serial, 0) + 1);
        if (map.get(serial) == 2) {
            ans.add(node);
        }
        return serial;
    }

    public static void main(String[] args) {
        // 输入
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        String[] lines = s.split(" ");

        // 层序遍历 递归创建二叉树
        TreeNode root = buildTree(lines);

        // 二叉树的层序遍历
        // levelOrder(root);
        List<TreeNode> duplicateSubtrees = findDuplicateSubtrees(root);

        for (TreeNode node: duplicateSubtrees) {
            System.out.print(node.val + " ");
        }
    }

    // 根据数组建树（不含null）
    /*
    public static TreeNode buildTree(String[] lines, int index) {
        if (index >= lines.length) return null;
        if (lines[index].equals("null")) return null;

        TreeNode node = new TreeNode(Integer.parseInt(lines[index]));
        node.left = buildTree(lines, 2*index+1);
        node.right = buildTree(lines, 2*index+2);
        return node;
    }*/

    // 根据数组建树（含null）
    public static TreeNode buildTree(String[] lines) {
        Queue<TreeNode> que = new LinkedList<>();
        int idx = 0;

        TreeNode root = new TreeNode(Integer.parseInt(lines[idx++]));
        que.offer(root);

        while(!que.isEmpty()) {
            TreeNode node = que.poll();
            if (idx == lines.length) break;

            // 左节点
            if (!lines[idx].equals("null")) {
                TreeNode tmp = new TreeNode(Integer.parseInt(lines[idx]));
                que.offer(tmp);
                // System.out.println(tmp.val);
                node.left = tmp;
            } else {
                node.left = null;
            }

            idx++;
            if (idx == lines.length) break;

            // 右节点
            if (!lines[idx].equals("null")) {
                TreeNode tmp = new TreeNode(Integer.parseInt(lines[idx]));
                que.offer(tmp);
                // System.out.println(tmp.val);
                node.right = tmp;
            } else {
                node.right = null;
            }
            idx++;
        }

        return root;
    }

    // 二叉树的层序遍历
    public static void levelOrder(TreeNode root) {
        Queue<TreeNode> que = new LinkedList<>();
        if (root == null) return;
        que.offer(root);

        while (!que.isEmpty()) {
            TreeNode node = que.poll();
            System.out.print(node.val + " ");
            if (node.left != null) que.offer(node.left);
            if (node.right != null) que.offer(node.right);
        }
    }
}