balanced Parantheses

import java.util.ArrayList;

public class BalancedParantheses {

    private static BitList globalParantheses;
    private static ArrayList<Character> globalNodes;

    /*
     * Task 1 : Transform
     * Write a method transform that can be called by
        transform( Tree, Parentheses, Nodes )
        and that transforms a given tree in prefix notation into a list of balanced parenthesis and a list of node
        names. You shall assume that node names are only letters ‘a’..’z’ and that the input Tree is syntactically
        correct.
     */
    public static void transform (String tree, BitList Parantheses, ArrayList<Character> Nodes) {
        //work through the tree input
        for(int i = 0; i < tree.length(); i++) {
            if(tree.charAt(i) >= 'a' && tree.charAt(i) <= 'z') {
                Parantheses.insert(true, Parantheses.getSize());
                Nodes.add(tree.charAt(i)); //add nodes
            }
            else if(tree.charAt(i) == ')' || tree.charAt(i) == ',') {
                Parantheses.insert(false, Parantheses.getSize());
            }
        }
        //add 0 to balance parantheses
        Parantheses.insert(false, Parantheses.getSize());
        globalNodes = Nodes;
    }
    /*
     * Task 2 : Basic Navigation
     * We assume that we have an unranked tree represented by a syntactically correct balanced
        parentheses bit string S, where each ‘(‘ is encoded by a 1-bit and each ‘)’ is encoded by a 0-bit. For
        example, S = [1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0]. We further assume that the current tree node is always
        represented by the position of a 1-bit in the bit string S.
        Implement a method fc (first-child) that can be called for each position pos where S[pos] is 1 by
        fc_pos = fc(S,pos)
        and that returns the position in S of the 1-bit representing the first child of the current tree node.
        If a tree node does not have a first child, the value of -1 shall be returned.
     */

    public static int fc(BitList S, int pos) {
         if(S.get(pos+1)) return pos+1;
        return -1;
    }

     /* Implement a method ns (next-sibling) that can be called for each position pos where S[pos] is 1 by
        ns_pos = ns(S,pos)
        and that returns the position in S of the 1-bit representing the next sibling of the current tree node.
        If a tree node does not have a next sibling, the value of -1 shall be returned.
     */
      public static int ns(BitList s, int position) {
            int count = 1;
            while(count != 0 && position < s.getSize() - 2)
             {
                int c = s.get(position)?-1:1;
                position++;
                count+=c;
                if(count == 0 & s.get(position+1)) return position+1;
            }
            return -1;
        }
    /*
    Implement a method fc1 (first-child^-1) that can be called for each position pos where S[pos] is 1 by
    fc1_pos = fc1(S,pos)
    and that returns the position in S of the 1-bit representing the parent of the current tree node if the
    current tree node is the first child of this parent.
    If the current tree node is not a first child of another tree node, the value of -1 shall be returned.
     */
    public static int fc1(BitList s, int position) {
        if(position != 0) {
            if(s.get(position-1)) return position-1;
        }
        return -1;
    }
    /*
     * Implement a method ns1 (next-sibling^-1) that can be called for each position pos where S[pos] is 1 by
        ns1_pos = ns1(S,pos)
        and that returns the position in S of the 1-bit representing the previous sibling of the current tree node
        if the current tree node is the next-sibling of this previous sibling.
        If the current tree node is not the next-sibling of another tree node, the value of -1 shall be returned.
     */
    // Reverse NextSibling
    public static int ns1(BitList s, int position) {
        if(position == 1) {
            int count = 0;
            while ( position >= 1) {
                position--;
                int c = s.get(position)?-1:1;
                count+=c;
                if(count == 0) return position;
            }
        }
        return -1;
        }
    /*
     * Implement a method pa (parent) that can be called for each position pos where S[pos] is 1 by
        pa_pos = pa(S,pos)
        and that returns the position in S of the 1-bit representing the parent of the current tree node.
        If the current tree node is the root node, the value of -1 shall be returned.
     */
    public static int pa(BitList s, int position) {
        if(position == 0) return -1;
        int count = 1;
        while(position > 0) {
            int c = s.get(position)?1:-1;
            count+=c;
        if(count == 0) return position;
        }

        return -1;
    }

    public static void test(String s) {
        //fill globalParantheses
        for(int i = 0; i < s.length(); i++) {
            if(s.charAt(i) == '1') globalParantheses.insert(true, globalParantheses.getSize());
            if(s.charAt(i) == '0') globalParantheses.insert(false, globalParantheses.getSize());
        }
        //now test it
        System.out.println("Test Part2 with ["+s+"] :");
        for(int i = 0; i < globalParantheses.getSize(); i++) {
            if(globalParantheses.get(i)) {
                System.out.println(retString(globalParantheses, i));
            }
        }

    }
    public static String retString(BitList s , int pos) {
        int fc_pos = fc(s, pos);
        int fc1_pos = fc1(s, pos);
        int ns_pos = ns(s,pos);
        int ns1_pos = -1;
        int pa_pos = -1;
        String t = "pos = " + pos + ", fc = " + fc_pos + ", ns = " + ns_pos + ", fc^-1 = "+fc1_pos
                + ", ns^-1 = " +ns1_pos + ", parent = " + pa_pos;
        return t;
    }


    public static void main(String[] args) {
        //init global variables
        globalParantheses = new BitList();
        globalNodes = new ArrayList<Character>();

        test("1,1,1,0,1,0,0,1,0,1,0,0");




    }
}