Bissoy.com
Doctors Medicines MCQs Q&A

Consider the pseudocode given below. The function DoSomething() takes as argument a pointer to the root of an arbitrary tree represented by the leftMostChild-rightSibling representation. Each node of the tree is of type treeNode. typedef struct treeNode* treeptr; struct treeNode {              treeptr leftMostChild, rightSibling; }; int DoSomething (treeptr tree) {              int value=0;              if (tree != NULL) {              if (tree->leftMostChild == NULL)              value = 1;    else               value = DoSomething(tree->leftMostChild);               value = value + DoSomething(tree->rightSibling);     }               return(value); } When the pointer to the root of a tree is passed as the argument to DoSomething, the value returned by the function corresponds to the 

Consider the pseudocode given below. The function DoSomething() takes as argument a pointer to the root of an arbitrary tree represented by the leftMostChild-rightSibling representation. Each node of the tree is of type treeNode. typedef struct treeNode* treeptr; struct treeNode {              treeptr leftMostChild, rightSibling; }; int DoSomething (treeptr tree) {              int value=0;              if (tree != NULL) {              if (tree->leftMostChild == NULL)              value = 1;    else               value = DoSomething(tree->leftMostChild);               value = value + DoSomething(tree->rightSibling);     }               return(value); } When the pointer to the root of a tree is passed as the argument to DoSomething, the value returned by the function corresponds to the  Correct Answer number of leaf nodes in the tree

Example:

[ alt="F1 R.S M.P 30.07.19 D 6" src="//storage.googleapis.com/tb-img/production/19/07/F1_R.S_M.P_30.07.19_D%206.PNG" style="width: 105px; height: 116px;">

height of the tree = 2

number of internal nodes = 2

number of nodes without a right sibling = 3

number of leaf nodes in the tree = 1

Node

Address

left child

right child

A (Root)

(1000)

B

null

B

(1002)

C

null

C

(1004)

null

null

 

DoSomething(1000)

value = DoSomething(1000->leftMostChild)  = DoSomething(1002);

value = DoSomething(1002->leftMostChild)  = DoSomething(1004);

value = DoSomething(1004->leftMostChild)  = DoSomething(null) → return 1

value = value + DoSomething(tree->rightSibling) =  1+ DoSomething(null) → return

value = value + DoSomething(tree->rightSibling) =  1+ DoSomething(null) → return

value = value + DoSomething(tree->rightSibling) =  1+ DoSomething(null) → return

Output: 1

The value returned by the function corresponds to the number of leaf nodes in the tree

Related Questions

The height of a tree is defined as the number of edges on the longest path in the tree. The function shown in the pseudocode below is invoked as height(root) to compute the height of a binary tree rooted at the tree pointer root. int height (treeptr n) { if (n == NULL) return -1;   if (n →  left == NULL)        if (n →  right == NULL) return 0;        else return ; \(\boxed{B1}\);     // Box 1 else { h1 = height (n →  left);          if (n → right == NULL) return (1+h1);          else { h2 = height (n → right);          return ; \(\boxed{B2}\)   // Box 2                        }            } } The appropriate expressions for the two boxes B1 and B2 are
Which of the following should be used for freeing the memory allocated in the following C code?
#include struct p{ struct p *next; int x;};int main(){ struct p *p1 = (struct p*)malloc(sizeof(struct p)); p1->x = 1; p1->next = (struct p*)malloc(sizeof(struct p)); return 0;}
The number of distinct nodes the following struct declaration can point to is . . . . . . . .
struct node{ struct node *left; struct node *centre; struct node *right;};
What is the output of following program? abstract class Sum { public abstract int sumOfTwo(int n1, int n2); public abstract int sumOfThree(int n1, int n2, int n3); public void disp( ){ System.out.println("Method of class Sum"); } } class DemoAbstract1 extends Sum { public int sumOfTwo(int num1, int num2) { return num1+num2; } public int sumOfThree(int num1, int num2, int num3) { return num1+num2+num3; } public static void main(String args[ ]){ Sum obj = new DemoAbstract1( ); System.out.println(obj.sumOfTwo(3, 7)); System.out.println(obj.sumOfThree(4, 3, 19)); obj.disp( ); } }
A circular queue has been implemented using a singly linked list where each node consists of a value and a single pointer pointing to the next node. We maintain exactly two external pointers FRONT and REAR pointing to the front node and the near node of the queue, respectively. Which of the following statements is/are CORRECT for such a circular queue, so that insertion and deletion operations can be performed in O(1) time? I. Next pointer of front node points to the rear node. II. Next pointer of rear node points to the front node.
A doubly linked list is declared as struct Node{                 int Value;                 struct Note*fwd;                 struct Node * Bwd; } Where Fwd and Bwd represent forward and backward link to the adjacent elements of the list. Which of the following segments of code deletes the node pointed to by X from the doubly liked list, if it is assumed that X points to neither the first nor the last node of the list?
Consider the following statements in connection with deflection-type and null-type instruments: 1. Null-type instruments are more accurate than the deflection-type ones. 2. Null-type of instrument can be highly sensitive compared to a deflection-type instrument. 3. Under dynamic conditions, null-type instruments are less preferred to deflection-type instruments. 4. Response is faster in null-type instruments as compared to deflection-type instruments. Which of the above statements are correct?
What is the output of this program? #include
using namespace std;
struct sec {
int a;
char b;
};
int main()
{
struct sec s ={25,50};
struct sec *ps =(struct sec *)&s;
cout << ps->a << ps->b;
return 0;
}
Point out the error (if any) in the following C code?
#include #include int main(void){ int* p = NULL; struct S *s = NULL; void(*f)(int, double) = NULL; char *ptr = malloc(15); if (ptr == NULL) printf("Out of memory"); free(ptr);}
What will output when you compile and run the following code?#include
struct student
{ int roll;
int cgpa;
int sgpa[8]; }; void main()
{ struct student s = { 12,8,7,2,5,9 };
int *ptr;
ptr = (int *)&s;
clrscr();
printf( "%d", *(ptr+3) );
getch(); }