Leetcode - Sword finger offer 37, 38

The finger of the sword Offer 37. Serialize binary tree 、38. Arrangement of strings

Title Description ：
[37]
Please implement two functions , Used to serialize and deserialize binary trees .

You need to design an algorithm to realize the serialization and deserialization of binary tree . There's no limit to your sequence / Deserialization algorithm execution logic , You just need to make sure that a binary tree can be serialized into a string and that the string can be deserialized into the original tree structure .

Tips ： Input output format and LeetCode The current usage is consistent , Please refer to LeetCode The format of serializing binary tree . You don't have to do this , You can also use other methods to solve this problem .
[38]
Enter a string , Print out all the permutations of the characters in the string .

You can return this array of strings in any order , But there's no repetition in it .
Key points of investigation ：
The first 37 topic Depth traversal implementation tree –> character string , How to generate a tree （ Using depth traversal , New at each step root, And return the value to root.Left and root.Right assignment ）
The first 38 topic Sort the string first , Then recursively traverse from front to back .

The first 37 topic

public class Codec {
    
public String makeString(TreeNode root){
    
            if(root == null){
    
                return "n";
            }
            String left = "," + serialize(root.left);
            String right = "," + serialize(root.right);
            return root.val + left + right;
        }
        // Encodes a tree to a single string.
        public String serialize(TreeNode root) {
    
            String res = makeString(root);
            return res;
        }

        public TreeNode makeTree(ArrayList<String> datas, TreeNode root){
    
            String nowC = datas.get(0);
            datas.remove(0);
            if(!nowC.equals("n")){
    
                root = new TreeNode(Integer.parseInt(nowC));
                root.left = makeTree(datas, root.left);
                root.right = makeTree(datas, root.right);
            }else{
    
                root = null;
            }
            return root;
        }
        // Decodes your encoded data to tree.
        public TreeNode deserialize(String data) {
    
            ArrayList<String> datas = new ArrayList<>(Arrays.asList(data.split(",")));
            if(datas.get(0).equals("n")){
    
                return null;
            }
            TreeNode root = new TreeNode(Integer.parseInt(datas.get(0)));
            datas.remove(0);
            root.left = makeTree(datas, root.left);
            root.right = makeTree(datas, root.right);
            return root;
        }
}

The first 38 topic

    boolean[] visit;
    ArrayList<String> res;
    int targetLen;
    public int dfs(char[] s, String nowWord){
    
        if(nowWord.length() == targetLen){
    
            res.add(nowWord);
            return 0;
        }
        for(int i = 0;i < targetLen;i ++){
    
            if(visit[i] || (i > 0 && s[i] == s[i-1] && visit[i-1]))
                continue;
            visit[i] = true;
            dfs(s, nowWord + s[i]);
            visit[i] = false;
        }
        return 0;
    }
    public String[] permutation(String s) {
    
        char[] arr = s.toCharArray();
        Arrays.sort(arr);
        targetLen = s.length();
        visit = new boolean[targetLen];
        res = new ArrayList<String>();
        dfs(arr, "");
        String[] tt = new String[res.size()];
        return res.toArray(tt);
    }