gistfile1.txt

/**
 * Definition for a binary tree node.
 * public 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;
 *     }
 * }
 */
class Solution {
    public TreeNode str2tree(String s) {
        TreeNode node_root = new TreeNode(0);
        
        ArrayList<TreeNode> nodeList = new ArrayList<TreeNode>();
        TreeNode newNode = null;
        
        HashMap<Integer, Map<Integer, Integer>> leftPars = new HashMap<Integer, Map<Integer, Integer>>();
        HashMap<Integer, Map<Integer, Integer>> rightPars = new HashMap<Integer, Map<Integer, Integer>>();
        HashMap<Integer, Integer> rightPar = new HashMap<Integer, Integer>();
        HashMap<Integer, Integer> leftPar = new HashMap<Integer, Integer>();
        
        int left=0, right=0, middle=0, num = 0;
        
        Integer height = 0, l_par = 0, r_par=0;
        int goRight = 0;
        String newSubString = s;
        int insideClose = 0, insideOpen = 0, outsideClose = 0, outsideOpen = 0; 
        
        while(right < newSubString.length() && left < right){
            right++;
            if(newSubString.charAt(right) == '('){
                num = Integer.parseInt(newSubString.substring(left++, newSubString.charAt(right)));
                middle = right;
                left = right;
                
                leftPar.put(l_par++,  right++);
                leftPars.put(height++,leftPar);   
                   
                System.out.println("Hello World");
                
                
                TreeNode currentNode = new TreeNode();
                currentNode = null;
                
                if (newNode == null){
                    newNode.val = num;
                    newNode = node_root;
                    nodeList.add(height, newNode);
                } else {
                    currentNode.val = num;
                    nodeList.add(height, currentNode);
                }
                while (l_par != r_par){
                    if (newSubString.charAt(right)== ')'){
                        
                        rightPar.put(r_par++, right++);
                        rightPars.put(--height, rightPar);
                    } 
                }
                
                if(l_par == r_par){
                    middle = right++;
                    newSubString = newSubString.substring(++left, middle);
                    
                    
                    
                    
                    if ( l_par == 2 && r_par ==2) {
                        // 4 with 2 leafs
                        //TO DO GET POSITIONS OF BOTH LEFT AND BOTH RIGHT PARS
                        char leftPar1 = ' ';
                        // leftPar1 = newSubString.charAt(leftPars.getValue(height, leftPar.size()));
                        char leftPar2 = ' ';
                        // leftPar2 = newSubString.charAt(leftPars.get(height, leftPar.leftPar.size()-1));
                        char rightPar1 = ' ';
                        // rightPar1 = newSubString.charAt(rightPars.get(height, rightPar.size()));
                        char rightPar2 = ' ';
                        // rightPar2 = newSubString.charAt(rightPars.get(height, rightPar.size()-1));
                        
                        if (leftPar2 == '(' && rightPar1 == ')'){
                            insideOpen = leftPar.get(l_par);
                            insideClose = rightPar.get(r_par -1);
                            num = Integer.parseInt(newSubString.substring(insideOpen +1 , insideClose));
                            TreeNode insideNode = new TreeNode(num);
                            nodeList.get(height).right = insideNode;
                            
                            outsideOpen = leftPar.get(l_par-1);
                            outsideClose = rightPar.get(r_par);
                            num = Integer.parseInt(newSubString.substring(outsideOpen , outsideClose));
                            TreeNode outsideNode = new TreeNode(num);
                            nodeList.get(--height).right = outsideNode;
                            
                        } else if (rightPar1 == ')' && leftPar2 == '('){
                            insideOpen = leftPar.get(l_par - 1);
                            insideClose = rightPar.get(r_par -1);
                            num = Integer.parseInt(newSubString.substring(insideOpen +1 , insideClose));
                            TreeNode leftNode = new TreeNode(num);
                            nodeList.get(--height).left = leftNode;
                            
                            outsideOpen = leftPar.get(l_par);
                            outsideClose = rightPar.get(r_par);
                            num = Integer.parseInt(newSubString.substring(outsideOpen , outsideClose));
                            TreeNode rightNode = new TreeNode(num);
                            nodeList.get(--height).right = rightNode;
                            
                        }
                    }
                }
            } 
        }
        
        return newNode;
    }
}
class parMap {
    private Integer height;
    private Map<Integer, Integer> parSpot;
}