Последователни броеви Problem 1 (3 / 6)
Со помош на нанижано бинарно дрво потребно е да проверите дали при inorder изминување на дрвото важи дека секој следен елемент има вредност за 1 поголема од претходниот (треба да се испечати true или false). Притоа доколку ви е потребно можете да користите дополнителни функции, но не смеете да користите рекурзија и дополнителни структури.

Име на класата во Java: ConsecutiveNumbers


import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.NoSuchElementException;
import java.util.StringTokenizer;
import java.util.Stack;
/*interface Stack<E> {

    // Elementi na stekot se objekti od proizvolen tip.

    // Metodi za pristap:

    public boolean isEmpty ();
        // Vrakja true ako i samo ako stekot e prazen.

    public E peek ();
        // Go vrakja elementot na vrvot od stekot.

    // Metodi za transformacija:

    public void clear ();
        // Go prazni stekot.

    public void push (E x);
        // Go dodava x na vrvot na stekot.

    public E pop ();
        // Go otstranuva i vrakja elementot shto e na vrvot na stekot.
}

class ArrayStack<E> implements Stack<E> {
    private E[] elems;
    private int depth;

    @SuppressWarnings("unchecked")
    public ArrayStack (int maxDepth) {
        // Konstrukcija na nov, prazen stek.
        elems = (E[]) new Object[maxDepth];
        depth = 0;
    }


    public boolean isEmpty () {
        // Vrakja true ako i samo ako stekot e prazen.
        return (depth == 0);
    }


    public E peek () {
        // Go vrakja elementot na vrvot od stekot.
        if (depth == 0)
            throw new NoSuchElementException();
        return elems[depth-1];
    }


    public void clear () {
        // Go prazni stekot.
        for (int i = 0; i < depth; i++)  elems[i] = null;
        depth = 0;
    }


    public void push (E x) {
        // Go dodava x na vrvot na stekot.
        elems[depth++] = x;
    }


    public E pop () {
        // Go otstranuva i vrakja elementot shto e na vrvot na stekot.
        if (depth == 0)
            throw new NoSuchElementException();
        E topmost = elems[--depth];
        elems[depth] = null;
        return topmost;
    }
}*/
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 static BNode<Integer> findNode(BNode<Integer> node, int n)
    {
        BNode<Integer> result = null;
        if(node==null)
        {
            return null;
        }
        //int x = node.info.intValue();
         if(node.info.intValue()==n)
        {
            return node;
        }
            if(node.left!=null)
                result = findNode(node.left, n);
            if(result==null)
                result = findNode(node.right,n);

        return result;
    }*/
    public void resultCheck(int N)
    {
        boolean flag = true;
        BNode<Integer> tmp = (BNode<Integer>)root;
        int pomos = 0;
        Stack<BNode<Integer>> stekce = new Stack<BNode<Integer>>();
        while(true)
        {
            while(tmp!=null)
            {
                stekce.push(tmp);
                //System.out.println(tmp.info);
                tmp = tmp.left;

            }
            if(stekce.isEmpty())
            {
                flag = true;
                //break;
                System.out.println("true");
                return;
            }
            tmp = stekce.pop();

            if(flag==false)
            {
                int pomos2 = tmp.info;
                //System.out.println(pomos2);
                //System.out.println(pomos);
                if(pomos2!=pomos+1)
                {
                    System.out.println("false");
                    return;
                }
                pomos = tmp.info;
            }
            if(flag==true)
            {
                pomos = tmp.info;
                flag = false;
            }
            //System.out.print(tmp.info + " ");
            tmp = tmp.right;
            if(flag==true)
                break;
        }
        //System.out.println("true");

        /*ArrayStack<BNode<Integer>> stekce = new ArrayStack<BNode<Integer>>(N);
        BNode<Integer> tmp = (BNode<Integer>)root;
        stekce.push(tmp);
        boolean flagce = true;
        boolean flagcule = true;
        int bukva = 0;
        while(!stekce.isEmpty())
        {
            System.out.println("prv loop");
            while(tmp!=null&&(tmp.info.equals(bukva)))
            {
                System.out.println("vtor loop");
                if(tmp.left!=null&&flagce)
                {
                tmp = tmp.left;
                stekce.push(tmp);
                }
                else if(tmp.left==null&&tmp.right!=null)
                {
                    System.out.println(tmp.info);
                    tmp = tmp.right;
                    stekce.push(tmp);
                }
                else if(tmp.right!=null)
                {
                    flagce = true;
                    tmp = tmp.right;
                    stekce.push(tmp);
                }
                else if(tmp.right==null&&tmp.left==null)
                {
                    System.out.println(tmp.info);
                    flagce = false;
                    BNode<Integer> x = stekce.pop();
                    bukva = x.info;
                    if(x.right!=null)
                    {
                        tmp = x.right;
                        continue;
                    }

                }
            }




        }*/
    }

}
public class ConsecutiveNumbers  {
    public static void main(String []args) throws Exception{
        int i, index;
        String action, 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 {
                tree.makeRootNode(nodes[index]);
            }


        }
        tree.resultCheck(N);
    }

}