class Solution {
    List<TreeNode> res=new LinkedList<>();
    Map<String,Integer> map=new HashMap<>();//用于存储子树
    public List<TreeNode> findDuplicateSubtrees(TreeNode root) {
        String x=find(root);
        return res;
    }
    public String find(TreeNode root){
        if(root==null) return "#";
        String left=find(root.left);
        String right=find(root.right);
        String myself=left+','+right+','+root.val;
        int count=map.getOrDefault(myself,0);
        if (count == 1) {
            res.add(root);
        }
        // 给子树对应的出现次数加一
        map.put(myself, count + 1);
        return myself;
    }
}

前序遍历 序列化和反序列化， 用新的函数帮忙Stringbuilder和 linkedlist  二叉树转字符串，

字符串转二叉树

public class Codec {
    String NULL="#";
    String SEP=",";
    StringBuilder sb=new StringBuilder();
    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        serializeHelp(root,sb);
        return sb.toString();
    }
    void serializeHelp(TreeNode root,StringBuilder sb){
        if(root==null){
            sb.append(NULL).append(SEP);
            return;
        }
        sb.append(root.val).append(SEP);
        serializeHelp(root.left,sb);
        serializeHelp(root.right,sb);
    }
    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
    LinkedList<String> nodes=new LinkedList<>();//用于存放结点
    String[] nodes1=data.split(SEP);//按逗号分隔字符串 得到字串数组
    for(String x:nodes1){
        nodes.add(x);
    }
    TreeNode res=deserialize(nodes);
    return res;
    }
    TreeNode deserialize(LinkedList<String> nodes){
        if(nodes.isEmpty()) return null;
        String node=nodes.removeFirst();
        if(node.equals(NULL)){
            return null;
        }
        TreeNode root=new TreeNode(Integer.parseInt(node));
        root.left=deserialize(nodes);
        root.right=deserialize(nodes);
        return root;
    }
}

归并算法（相当于后序遍历 ，sort时没排序，主要是到了merge时候排序

递归算法 注意传参 注意传参 递归算法 注意传参，因为递归值是会变化的所以传入的是形参！！

归并排序，左边排序，右边排序 最后merge  要新建一个辅助数组 便于原地修改

class Solution {
    int[] temp;
    public int[] sortArray(int[] nums) {
        temp=new int[nums.length];
        sort(nums,0,nums.length-1);
        return nums;
    }
    void sort(int[] nums,int left,int right){
        if(left==right) return;//单个不用排序
        int mid=(left+right)/2;
        sort(nums,left,mid);
        sort(nums,mid+1,right);
        merge(nums,left,mid,right);
    }
    void merge(int[] nums,int left,int mid,int right){//双指针
        for(int i=left;i<=right;i++){
            temp[i]=nums[i];//复制数值,在temp上操作
        }
        int p1=left,p2=mid+1;//p用于操作temp，p1左数组，p2右数组
        for(int p=left;p<=right;p++){
            if(p1==mid+1){//左数组放完了,放右数组
                nums[p]=temp[p2++];
            }else if(p2==right+1){//右数组放完
                nums[p]=temp[p1++];
            }else if(temp[p1]<temp[p2]){
                nums[p]=temp[p1++];
            }else{
                nums[p]=temp[p2++];
            }
        }
    }
}