Leetcode-297 serialization and deserialization of binary tree

subject

Ideas

1. Record its preorder traversal and inorder traversal and length Building a binary tree
2. The difficulty lies in building , It should be built recursively , I wrote it myself before , It seems that I can't write at all now …
3. After a long time, I found that I ignored the situation of negative numbers and multiple numbers … Vomiting blood

Code

    // You can save through traversal   First record root As the first character   The middle order traversal and the pre order traversal are recorded later 
    StringBuilder ans = new StringBuilder();
    int length=0;
    public String serialize(TreeNode root) {
    
        // First record first order 
        pre(root);
        // Record length 
        ans.insert(0,length);
        ans.insert(1," ");

        // In the sequence traversal 
        order(root);
        return ans.toString();
    }
    public void pre(TreeNode root){
    
        if(root==null) return;
        ans.append(root.val+" ");
        length++;
        if(root.left!=null) pre(root.left);
        if(root.right!=null) pre(root.right);
    }
    public void order(TreeNode root){
    
        if(root==null) return;
        if(root.left!=null) order(root.left);
        ans.append(root.val+" ");
        if(root.right!=null) order(root.right);
    }
    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
    
        String[] arr = data.split(" ");
        // To obtain the length of the   Intercepting string 
        int length = Integer.valueOf(arr[0]);
        // Intercepting preorder and inorder strings 
        int[] pre =new int[length];
        int[] order = new int[length];

        for(int i=0;i<length;i++) pre[i] = Integer.valueOf(arr[1+i]);
        for(int i=0;i<length;i++) order[i] = Integer.valueOf(arr[1+i+length]);

        return Resume(pre,order);
    }
    public TreeNode Resume(int[] pre,int[] order){
    
        if(order.length==0) return null;
        // The root node 
        TreeNode root = new TreeNode(pre[0]);
        // Root node found in order Position in   You can find the position of its left and right subtrees 
        int local=0;
        while (order[local] !=root.val) local++;
        // Began to intercept   Because it's an array   So new 
        int[] left_pre = Arrays.copyOfRange(pre,1,pre.length);
        int[] left_order = Arrays.copyOfRange(order,0,local);
        int[] right_pre = Arrays.copyOfRange(pre,local+1,pre.length);
        int[] right_ord = Arrays.copyOfRange(order,local+1,order.length);


        root.left = Resume(left_pre,left_order);
        root.right = Resume(right_pre,right_ord);
        return root;
    }