Recover a Tree From Preorder Traversal | Leetcode 1028

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    int getVal(string& traversal,const int& n,int& pos){
        int val = 0;
        while(pos<n and traversal[pos]>='0' and traversal[pos]<='9'){
            val = val*10 + (traversal[pos]-'0');
            pos++;
        }
        return val;
    }
    int getDashLen(string& traversal,const int& n,int& pos){
        int dash_len = 0;
        while(pos<n and traversal[pos]=='-'){
            dash_len++;
            pos++;
        }
        return dash_len;
    }
    void buildTree(TreeNode* curr,int expected_dash_len,string& traversal,const int& n,int& pos){
        if(pos==n)  return;

        int prev_pos = pos;
        int dash_len = getDashLen(traversal,n,pos);

        //If the newnode is not a child of current node, then return back
        if(dash_len < expected_dash_len){
            pos = prev_pos;
            return;
        }
        //Find node_val and make newnode
        int node_val = getVal(traversal,n,pos);
        TreeNode* newnode = new TreeNode(node_val);
        if(!curr->left) curr->left = newnode;
        else            curr->right = newnode;

        buildTree(newnode,1+expected_dash_len,traversal,n,pos);
        buildTree(newnode,1+expected_dash_len,traversal,n,pos);
    }
public:
    TreeNode* recoverFromPreorder(string traversal) {
        int n=traversal.size();
        int pos=0;
        TreeNode *root = new TreeNode(getVal(traversal,n,pos));
        
        buildTree(root,1,traversal,n,pos);
        buildTree(root,1,traversal,n,pos);
        return root;
    }
};
/*
//JAVA
class Solution {
    public TreeNode recoverFromPreorder(String traversal) {
        int[] pos = new int[1];
        int n = traversal.length();
        if (n == 0) return null;
        int rootVal = getVal(traversal, n, pos);
        TreeNode root = new TreeNode(rootVal);
        buildTree(root, 1, traversal, n, pos);
        buildTree(root, 1, traversal, n, pos);
        return root;
    }
    
    private int getVal(String traversal, int n, int[] pos) {
        int val = 0;
        while (pos[0] < n && Character.isDigit(traversal.charAt(pos[0]))) {
            val = val * 10 + (traversal.charAt(pos[0]) - '0');
            pos[0]++;
        }
        return val;
    }
    
    private int getDashLen(String traversal, int n, int[] pos) {
        int originalPos = pos[0];
        while (pos[0] < n && traversal.charAt(pos[0]) == '-') {
            pos[0]++;
        }
        return pos[0] - originalPos;
    }
    
    private void buildTree(TreeNode curr, int expectedDashLen, String traversal, int n, int[] pos) {
        if (pos[0] == n) return;
        int originalPos = pos[0];
        int dashLen = getDashLen(traversal, n, pos);
        if (dashLen != expectedDashLen) {
            pos[0] = originalPos;
            return;
        }
        int nodeVal = getVal(traversal, n, pos);
        TreeNode newNode = new TreeNode(nodeVal);
        if (curr.left == null) {
            curr.left = newNode;
        } else {
            curr.right = newNode;
        }
        buildTree(newNode, expectedDashLen + 1, traversal, n, pos);
        buildTree(newNode, expectedDashLen + 1, traversal, n, pos);
    }
}

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

#Python
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def recoverFromPreorder(self, traversal: str) -> TreeNode:
        pos = [0]
        n = len(traversal)
        if n == 0:
            return None
        root_val = self._get_val(traversal, n, pos)
        root = TreeNode(root_val)
        self._build_tree(root, 1, traversal, n, pos)
        self._build_tree(root, 1, traversal, n, pos)
        return root
    
    def _get_val(self, traversal, n, pos):
        val = 0
        while pos[0] < n and traversal[pos[0]].isdigit():
            val = val * 10 + int(traversal[pos[0]])
            pos[0] += 1
        return val
    
    def _get_dash_len(self, traversal, n, pos):
        start = pos[0]
        while pos[0] < n and traversal[pos[0]] == '-':
            pos[0] += 1
        return pos[0] - start
    
    def _build_tree(self, curr, expected_dash_len, traversal, n, pos):
        if pos[0] >= n:
            return
        original_pos = pos[0]
        dash_len = self._get_dash_len(traversal, n, pos)
        if dash_len != expected_dash_len:
            pos[0] = original_pos
            return
        node_val = self._get_val(traversal, n, pos)
        new_node = TreeNode(node_val)
        if not curr.left:
            curr.left = new_node
        else:
            curr.right = new_node
        self._build_tree(new_node, expected_dash_len + 1, traversal, n, pos)
        self._build_tree(new_node, expected_dash_len + 1, traversal, n, pos)

*/

can you share the JS solution for the same logic?