How to answer the following question screenshot shows our binary search treeFor the binary search trees, the public method, size, calls the private recursive method, recSize, and passes it a reference to the root of the tree, returning to the caller whatever is returned to it by recSize. Critique the following implementation of recSize assuming its parameter variable is node:if (node == null) return 0;elseif ((node.getLeft() == null) && (node.getRight() == null)) return 1;elseif ((node.getLeft() == null)) return (1 + recSize(node.getRight()));else return (1 + recSize(node.getLeft()));A. The code will throw a "null pointer exception" under certain circumstances.B. The code will return an incorrect result under certain circumstances.C. The code works correctly but could be simpler.D. The code works correctly. If an application uses the remove method on an Iterator object returned by our binary search tree:A. a TreeUnderflowException is thrown.B. an UnsupportedOperationException is thrown.C. the application will terminate.D. the most recently visited node of the tree will be removed. //Page1import jayautil.*; // Iterator, Comparatorpublic class BinaryRarchTcee implements BSTpterfacesT>{protected BSTNodę rogtin // reference to the root of this BSTprotected Comparator gompin/ used for all comparisons//page2BSTNede node = root;while (nodesetRightl) != null)node = nede getRiebt();return node getlnfel);//page3private T resGet(T target, BSTNedesT> node)// Returns info i from the subtree rooted at node such that// comBSAVORAKeltarget, i) == 0; if no such info exists, returns null.{if (node == null)return nyllinelse if (comBSORare(target, node setlotel) < 0)return resGet(target, nede-setleftl));protected boolean found/ used by removeprivate int recSizeBSTNedesT> node)// Returns the number of elements in subtree rooted at node.// target is not foundpublic BipatxSearchtreel)// Precondition: Timplements Comparable// Creates an empty BST object - uses the natural order of elements.{root = null;comp = new Comparator 0)return resfet(target, podegetRiebt();elseelse// get from right subtreereturn 1+ ressizeloode.getleft() + tesSizeloode.getBight());}return pode getlnfo(); // target is found}public int sized// Returns the number of elements in this BST.{return recSize(root);}public T get(T target)// Returns info i from node of this BST where comp.coRare(target, i == 0;// if no such node exists, returns null.{};return recGet(target, root);}public int size2()// Returns the number of elements in this BST.{int count = 0;if (roote null){LiokedStack> nodeStack = new LipkedStack>);BSTNode GUTNode:Dodestack Rusb(root);while (!podeStackisEmotx(){EUTNode= vedestacktop);vedestask pop);count++;if (gyrrNode.getlet(Q4= null)odestaskRusblouNodegetlet();if (gurONode BRtBigbt()A= null)oodestackpusbleurTNode.getBight();public BinatxSearctree(Comparator comp)// Creates an empty BST object - uses Comparator comp for order// of elements.{root = null;this cema = comp;}private BSTNedesT> recaddU element, BSTNede node)// Adds element to tree rooted at node; tree retains its BST property.{if (node == null)// Addition place foundnode = new BSTNode(element);else if (comasoraKe(element, nodesetlotel)) <= 0)DodesetlefticesAddlelement, pode getleft()); // Add in left subtreepublic booleanisEUUO// Returns false: this link-based BSTs never full.{return false;}elsevodesetRiebtlcesAdd(element, nodegetRiebt()); // Add in right subtreereturn node;}public booleaoisEMrty)// Returns true if this BST is empty; otherwise, returns false.{return (root == null);}public booleao add (T element)// Adds element to this BST. The tree retains its BST property.{root = (RCAddlelement, root);}return true;}public T minl)// If this BST is empty, returns null;// otherwise returns the smallest element of the tree.return count;}/*public booleao add (T element)// Adds element to this BST. The tree retains its BST property.{private booleanrecCootaios(T target, BSTNodesT> node)// Returns true if the subtree rooted at node contains info i such that// CAMBSOVORare(target, i) == 0; otherwise, returns false.{if (node == null)return falsen // target is not foundelse if (comeSoaRara(target, nodesetlotel)) < 0)return resContains(target, pode getleft(); // Search left subtreeelse if (comeSomRare(target, node setlotel) > 0)return resContains(target, node getRight()); // Search right subtreeif (işEmptv)return null;elseBSTNodesT> newNode= new BSTNede(element);BSTNedesT> RKEK= null, cu = null;{BSTNedesT> node = root;while (node getletl) != null)node = nede seteft();return node getlofel);if (root == null)root = newdode:else{GUK = root;while (gyTJ= null)}elsereturn tryen // target is found}public T max()// If this BST is empty, returns null;// otherwise returns the largest element of the tree.{if (iŞEmpty)return null;if (comB.SoMparalelement, çyrr,getlnfo()) <= 0){public boolean.contains (T target)// Returns true if this BST contains a node with info i such that// comBsoORAe(target, i) == 0; otherwise, returns false.{return resContains(target, root);}DAX = CUEUTK= CUEstleft();}elseelse{{ //page4//page6|//page5public Iterator getiterator(BSTloterfaceTraversal exderTvre)// Creates and returns an Iterator providing a traversal of a "snapshot"// of the current tree in the order indicated by the argument.// Supports Preorder, Pestorder, and pordettraversal.{final LipkedQueue infoQueue= new LinkedQueue node, LiokedQueue q)// Enqueues the elements from the subtree rooted at node into q in postorder,if (nodel null){9ostorderloode getleft(), q);9ostorderloede setRiebt(), q);GenaVRuelvedeeetlofe();}elseprAKSRtLetlvewdode);}return true;if (exderTure == BSTIoterface-TcaversalhJoerder)inArdertroot, infoQuevel;else}public Iterator iterator)// norder is the default, "natural" order.if (orderTure== BSToterfaceTraversal Rosterderd9ostorderdroot, inteQueue);private T getPredecessed(BSTNede subtree)// Returns the information held in the rightmost node of subtree{BSTNedesT> temp = subtree;while (teroB getBight() != null)temp = tempgetBiebt();return terpgetlatel);}return getiterator(ESToterfaceTraversalloerder);}return new Iterator removeNedelBSTANede node)// Removes the information at node from the tree.{T data;if (vode setleft) == null)return pode getBight();else if (nedesetRiebt() == null)return node getleft();public T next)// Returns the next element in the iteration.// Throws NoSycbElementExcention - if the iteration has no more elements{if (UbasNext())throw new ndexQutOfBoundsExcention("illegal invocation of next "+else'in BinarySearcbTeR iterator.\n");return infoQueuesdeaURuel);}{data = getRredeceSSoulvede-getleftl));Dodesetloteldata);oodesetleftltecRemeveldata, pode getleft());return node;public void remove)// Throws UpsuppetedOrerationException.// Not supported. Removal from snapshot iteration is meaningless.}{throw new UpsuRroctedOperatienExsention("Unsupported remove attempted on "private BSTNodesT> recBemexe(T target, BSTNodesT> node)// Removes element with info i from tree rooted at node such that+ "BinanSearsbTceR iterator.\n");}};}// CROBSOVORAKe(target, i == 0 and returns true;// if no such node exists, returns false.{if (node == null)found = false;private void preQrder(BSTNode node, LipkedQueue q)// Enqueues the elements from the subtree rooted at node into q in preorder,{if (vedel null){GenaUeuelvodesetlofel);prerderlvede getleft(), q);preederlvede.getRigbt(), q);}}else if (compSomRare(target, node setlotel) < 0)DodesetleftlterRemeveltarget, pode getleft());else if (comp.compare(target, nodegetlofel) > 0)vodesetRiebtlcesRemeve(target, node gstBight());else{node = removeNode(node);found = true;}return node;}private void inOrder(BSTNedesT> node, linkedQueue q)// Enqueues the elements from the subtree rooted at node into q in inorder,{if (nodel null){inOrderloode geteft(), q);gAnavevelvedegetlofel);inorderloodegetRiebt(), g);public booleaoremove (T target)// Removes a node with info i from tree such that compOparaltargeti == 0// and returns true; if no such node exists, returns false.{root = recBemeveltarget, root);return found;}

BST is a data structure that allows us to maintain sorted list of numbers. Each tree node has maximum of 2 children. Operations such as search, insert, delete can be applied on BST.For our binary search trees, the public method, size, calls the private recursive method, recSize, and passes it a reference to the root of the tree, returning to the caller whatever is returned to it by recSize. Critique the following implementation of recSize, assuming its parameter variable is node:if (node == null)return 0;elsereturn 1 + recSize(node.getLeft()) + recSize(node.getRight());Answer: Option D) The code works correctly.Reason:Size of a tree is number of elements present in the tree.i.e., size of a tree = size of left subtree + size of right subtree + 1.From the given data, size() function calls the recrusive function recSize() which accepts a node as a parameter.If node is null then it returns 0Otherwise it recursively calls recSize() function for the left subtree i.e., recSize(node.getLeft()) and recSize() function for the right subtree i.e., recSize(node.getRight()) + 1.The recursive call continues till it reaches the leaf node at each call.So the codes finally returns the height of the left subtree + height of the right subtree + 1.So the code works correctly.If an application uses the remove method on an Iterator object returned by our binary search tree an an UnsupportedOperationException is thrown.Explanation : Iterator is used to iterate over the traversals of a BST but not used to remove method on an iterator object returned by our BST. Thus UnsupportedOperationException is thrown (requested operation is not supported).Thus option B is correct.Thus answers are :Question 1 : Option D) The code works correctly.Question 2 : Option B) UnsupportedOperationException is thrown.