Збир на елементи во бинарно дрво (итеративно решение) АПС

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

class BNode<E> {

    public E info;
    public BNode<E> left;
    public BNode<E> right;

    static int LEFT = 1;
    static int RIGHT = 2;

    public BNode(E info) {
        this.info = info;
        left = null;
        right = null;
    }

    public BNode() {
        this.info = null;
        left = null;
        right = null;
    }

    public BNode(E info, BNode<E> left, BNode<E> right) {
        this.info = info;
        this.left = left;
        this.right = right;
    }

}

class BTree<E extends Comparable<E>> {

    public BNode<E> root;

    public BTree() {
        root = null;
    }

    public BTree(E info) {
        root = new BNode<E>(info);
    }

    public void makeRoot(E elem) {
        root = new BNode(elem);
    }

    public void makeRootNode(BNode<E> node) {
        root = node;
    }

    public BNode<E> addChild(BNode<E> node, int where, E elem) {

        BNode<E> tmp = new BNode<E>(elem);

        if (where == BNode.LEFT) {
            if (node.left != null)  // veke postoi element
                return null;
            node.left = tmp;
        } else {
            if (node.right != null) // veke postoi element
                return null;
            node.right = tmp;
        }

        return tmp;
    }

    public BNode<E> addChildNode(BNode<E> node, int where, BNode<E> tmp) {

        if (where == BNode.LEFT) {
            if (node.left != null)  // veke postoi element
                return null;
            node.left = tmp;
        } else {
            if (node.right != null) // veke postoi element
                return null;
            node.right = tmp;
        }

        return tmp;
    }

}

public class BinaryTreeSum {

    private static BNode<Integer> getStartingNode(int baranaVrednost, Queue<BNode<Integer>> treeQueue) {
        BNode<Integer> theChosenOne = new BNode<>();

        while(treeQueue.size() > 0){
            BNode<Integer> node = treeQueue.peek();

            if(node.info == baranaVrednost){
                theChosenOne = node;
                break;
            }

            treeQueue.remove();
            if(node.left != null)
                treeQueue.add(node.left);
            if(node.right != null)
                treeQueue.add(node.right);
        }
        treeQueue.clear(); //clear queue in case theChosenOne was found before the queue was emptied
        return theChosenOne;
    }

    private static int getSumFromTree(BNode<Integer> startingNode, BNode<Integer> parentNode, Queue<BNode<Integer>> treeQueue, boolean type){
        treeQueue.add(startingNode);

        int sum = 0;

        while(!treeQueue.isEmpty() && startingNode != null){
            startingNode = treeQueue.poll();

            if(startingNode.left != null){
                treeQueue.add(startingNode.left);
            }
            if(startingNode.right != null){
                treeQueue.add(startingNode.right);
            }
            //If type == true, sum all nodes.info that are smaller than parentNode.info, else..
            if(type){
                if(startingNode.info < parentNode.info)
                    sum += startingNode.info;
            }
            else {
                if(startingNode.info > parentNode.info)
                    sum += startingNode.info;
            }
        }
        return sum;
    }


    public static void main(String[] args) throws Exception {
        int i, j, k;
        int index;
        String action;

        String line;

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        int N = Integer.parseInt(br.readLine());

        BNode<Integer> nodes[] = new BNode[N];
        BTree<Integer> tree = new BTree<Integer>();

        for (i=0;i<N;i++)
            nodes[i] = new BNode<Integer>();

        for (i = 0; i < N; i++) {
            line = br.readLine();
            st = new StringTokenizer(line);
            index = Integer.parseInt(st.nextToken());
            nodes[index].info = Integer.parseInt(st.nextToken());
            action = st.nextToken();
            if (action.equals("LEFT")) {
                tree.addChildNode(nodes[Integer.parseInt(st.nextToken())], BNode.LEFT, nodes[index]);
            } else if (action.equals("RIGHT")) {
                tree.addChildNode(nodes[Integer.parseInt(st.nextToken())], BNode.RIGHT, nodes[index]);
            } else {
                // this node is the root
                tree.makeRootNode(nodes[index]);
            }
        }

        int baranaVrednost=Integer.parseInt(br.readLine());

        br.close();

        // vasiot kod ovde

        BNode<Integer> current = tree.root;
        Queue<BNode<Integer>> treeQueue = new LinkedList<>();
        treeQueue.add(current);

        BNode<Integer> parentNode = getStartingNode(baranaVrednost, treeQueue);

        BNode<Integer> leftTree = parentNode.left;
        int leftTreeSum = getSumFromTree(leftTree, parentNode, treeQueue, true);

        BNode<Integer> rightTree = parentNode.right;
        int rightTreeSum = getSumFromTree(rightTree, parentNode, treeQueue, false);

        System.out.println(leftTreeSum + " " + rightTreeSum);
    }
}