寻找重复子树

华为笔试第三题，二叉树的建树过程也要自己写哈

这里记录一下哈，用的递归的写法

import java.util.*;
import java.io.*;
public class Main {
    static Map<String, Integer> map;    // 查看是否存在重复子树
    static List<TreeNode> list; // 重复子树的根节点

    static class TreeNode {
        int val;
        TreeNode left, right;
        TreeNode() {}
        TreeNode(int val) {
            this.val = val;
        }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }

    static TreeNode stringToTree(String line) {
        line = line.trim();
        line = line.substring(1, line.length() - 1);
        if (line.length() == 0) return null;
        String[] strings = line.split(",");
        String nodeVal = strings[0];
        TreeNode root = new TreeNode(Integer.parseInt(nodeVal));
        // 层序遍历 建树
        Deque<TreeNode> que = new LinkedList<>();
        que.offer(root);
        int index = 1;
        while (!que.isEmpty()) {
            TreeNode tmp = que.poll();
            if (index == strings.length) {
                break;
            }
            nodeVal = strings[index++];
            nodeVal = nodeVal.trim();
            if (!"null".equals(nodeVal)) {
                int leftVal = Integer.parseInt(nodeVal);
                tmp.left = new TreeNode(leftVal);
                que.offer(tmp.left);
            }

            if (index == strings.length) {
                break;
            }

            nodeVal = strings[index++];
            nodeVal = nodeVal.trim();
            if (!"null".equals(nodeVal)) {
                int rightVal = Integer.parseInt(nodeVal);
                tmp.right = new TreeNode(rightVal);
                que.offer(tmp.right);
            }
        }
        return root;
    }
    // 递归
    static String getPreOrder(TreeNode node) {
        if (node == null) {
            return "#";
        }
        String res = node.val + "," + getPreOrder(node.left) + "," + getPreOrder(node.right);
        map.put(res, map.getOrDefault(res, 0) + 1);
        if (map.get(res) == 2) {
//            System.out.println("添加了节点" + node.val);
            // 递归 实际是从下往上添加
            list.add(node);
        }
        return res;
    }

    //
    static void print(TreeNode node) {
        // 层序遍历 建树
        Deque<TreeNode> que = new LinkedList<>();
        StringBuilder res = new StringBuilder("[");
        res.append(node.val);
        que.offer(node);
        while (!que.isEmpty()) {
            TreeNode tmp = que.poll();
            if (tmp.left != null) {
                res.append("," + tmp.left.val);
                que.offer(tmp.left);
            } else {
                res.append(",null");
            }

            if (tmp.right != null) {
                res.append("," + tmp.right.val);
                que.offer(tmp.right);
            } else {
                res.append(",null");
            }
        }
        res.append("]");
        System.out.println(res.toString());
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // 层序遍历建立树
        String string = sc.nextLine();
        TreeNode root = stringToTree(string);
        // print(root);
        map = new HashMap<>();
        list = new ArrayList<>();
        getPreOrder(root);
        if (list.size() == 0) {
            System.out.println("-1");

        } else {
            TreeNode result = list.get(list.size() - 1);
            print(result);
        }
    }
}