Solution

Inorder traversal has the sequence of left-root-right.

And Binary search tree has the property that, for every node, the elements if left subtree are less that the noded value. Similarly the nodes in right subtree are always greater than the node.

Hence when we do inorder traversal of any such BST it will give a sorted sequence of elements. Take following example:

Inorder traversal of above tree is: 2, 9, 12, 16, 20

Solution

Lets evaluate using stack method:

1 4 18 6 / 3 + + 5 / +

Solution

void fun(int, long);

void fun(int x, long y)

{}

void main ()

{

int i = 10;

long j = 120;

long *p = &j;

fun(i,*p);

}

It is clearly mentioned the return type of fun is void hence we call fun in main, we should not take value from fun, as shown in B.

By doing option elimination

i = fun(i, j) is false because f’s return type is void, but here shown as int.

Now, coming to option fun( j, *j) and fun(i, *j), the 2nd parameter of the fun is of long type and not pointer,

Hence, fun( j, *j) & fun(i, *j) can be eliminated as j is a long variable and not a pointer variable.

Coming to option fun(i, *p)

i = 10

*p = 120, which is long

Hence the fun(i, *p) is syntactically correct calling of fun into main, which will not lead any error like a,b,c.

Solution

d = 1 2 3

∴ ⇒ 3 1 2 2 3 3

d = 1 2 3

void count(int n) {

static int d=1;

printf("%d ", n);

printf("%d ", d);

d++;

if(n>2) count(n-1);

printf("%d ", d);

}

count(3)

d= 1 | 2

Print : 3

Print : 1

d++ // d=2

n = 3 > 2 hence true, therefore

count(2) // after this call last printf(d), will be printed with the latest value of d, as d is static, having only one copy in memory

d= 1 | 2 | 3

Print : 2

Print : 2

d++ // d=3

n = 2 > 2 : This is false hence if block will not be executed.

Print: 3 // current value of d, This printf is last line of count(2)

Print: 3 // Current value of d, This printf is last line of count(3)

Solution

( ( ) ( ( ) ) ( ( ) ) )

If you see the stack in above example, then maximum number of elements in the stack are 3 at any instance.

Solution

When j is 30, the function would call itself again and again as neither i nor j is changed inside the recursion.

Solution

Option c is incorrect because pointer to a variable is ptr = &x

Pointer to an array:

Pointer to an array is also known as array pointer. We are using the pointer to access the components of the array.

int a[3] = {3, 4, 5 };

int *ptr = a;

We have a pointer ptr that focuses to the 0th component of the array. We can likewise declare a pointer that can point to whole array rather than just a single component of the array.

Syntax:

data type (*var name)[size of array];

Declaration of the pointer to an array:

// pointer to an array of five numbers

int (* ptr)[5] = NULL;

The above declaration is the pointer to an array of five integers. We use parenthesis to pronounce pointers to an array. Since subscript has higher priority than indirection, it is crucial to encase the indirection operator and pointer name inside brackets.

Precedence of () and [] is higher than *.

Among () and [], associativity is from left to right.

Hence (*ptr) is a pointer to an int array of size 5.

Array of pointers:

“Array of pointers” is an array of the pointer variables. It is also known as pointer arrays.

Syntax:

int *var_name[array_size];

Declaration of an array of pointers:

int *ptr[3];

We can make separate pointer variables which can point to the different values or we can make one integer array of pointers that can point to all the values.

Solution

After inserting 76, 84, 52, 74, 2 in a sequence in an AVL tree the tree will look like the following. There wont be any imbalance till these many insertions.

After 2, 42 is inserted in a tree this will lead to imbalance at node 76

The LL imbalance from 76-52 and 52-2 will be adjusted as follows:

Next 40 will be inserted, and again an imbalance occurs at node 2.

The RL imbalance at 2-42 and 42-40 will be balanced by rotation and tree will be balanced as follows:

In this way while inserting a sequence of 76, 84, 52, 74, 2, 42, 40 into an empty AVL tree , there will be 2 rotations required after the insertion of 42 and 40 respectively.

Solution

Irrespective of the type of pointer, the size for a pointer is always same. So whether it’s pointer to char or pointer to float, the size of any pointer would be same. Even size of a pointer to user defined data type (e.g. struct) is also would be same.

Solution

func1(char* s1, char* s2){

char* temp;

temp = s1;

s1 = s2;

s2 = temp;

}

Everything is local here. So, once the function completes its execution all modifications go in vain.

func2(char** s1, char** s2){

char* temp

temp = *s1

*s1 = *s2

*s2 = temp

}

This will retain modification and swap pointers of string.

So output would be Corona Go Go Corona

Solution

Element A[11][0] is stored at "Base Address + 11 * 10 * 4" which is "Base Address + 440" = 540. So A[11][5] is stored at 540 + 5*4 = 560.

Solution

Though arr[ ][ ] is 2D array, arr[2] represents 3rd row of array which has starting address same as address of element ‘7’.

Solution

The above program gives following error:

error: assignment to expression with array type

for s=”Gate”; line.

If we want to initialize an array, C allows us to fill it with values. So

char s[100] = "Gate";

is a valid line of code.

But, C doesn't allow us to do the assignment since s is an array and not a free pointer. The meaning of

s = "Gate";

is to assign the pointer value of abcd to s but you can't change s since then nothing will be pointing to the array.

This can and does work if s is a char* - a pointer that can point to anything.

If we want to copy the string simple use strcpy.

strcpy(a, "Gate");

Solution

Very interesting code to find a minimum and it works!

The only restriction, numbers must be positive!

The meaning is simple: when x < y we return 0, otherwise we return x - y.

Now, consider all possible cases with 0 < x, y:

x < y:

find(x, find(x,y)) == find(x, 0) == x - 0 == x == min(x, y)

x == y:

find(x, find(x,y)) == find(x, x - y) == find(x, 0) == x - 0 == x == min(x, y)

x > y:

find(x, find(x,y)) == find(x, x - y) == x - (x - y) == y == min(x, y)

With negative numbers it does not work.

Solution

typedef struct Record

{

char ename[30];

int ssn;

int deptno;

} employee;

Record is tag-name. ’employee’ is nothing but New Data Type. We can now create the variables of type ’employee’. Tag name is optional in the structure declaration

The typedef keyword is used to create new data type names. For example:

typedef int Length;

Hence in the declaration of structure, if we specify the ‘typedef’ keyword then it will make ‘employee’ a new data type.

Solution

"ptr is a pointer to int."

Because the C language does not specify an implicit initialization for objects of automatic storage duration, care should often be taken to ensure that the address to which ptr points is valid; this is why it is sometimes suggested that a pointer be explicitly initialized to the null pointer value.

Dereferencing a null pointer in C produces undefined behavior, which could be catastrophic(involving or causing sudden great damage or suffering). However, most implementations simply halt execution of the program in question, usually with a segmentation fault.

Solution

#include <stdio.h>

void my_fun(int x){

printf( "%d\n", x );

}

int main(){

void (*fptr)(int);

// fptr = &my_fun; /*Valid statement*/

fptr = my_fun; /* the ampersand is actually optional */

/* call my_fun (note that you do not need to write (*fptr)(2) ) */

fptr( 2 );

/* but if you want to, you may */

(*fptr)( 2 );

return 0;

Solution

Inorder traversal of a binary search tree always produces the keys in increasing order.

But the question Reverse ordering of natural numbers are used i.e. 19 is assumed to be the smallest and 10 to be the largest. So the sequence in increasing order will be 19, 18, 17, 16, 15, 14, 13, 12, 11, 10. So, option (D) is correct.

Solution

When we delete root node, tree will be

but this tree is not balance, so we will find inorder predecessor (according to question) and replace it will root node now.

16 is the inorder predecessor.

Hence,

⇒ 16 is the new root node.

Solution

When we delete the root node, the root node position will be empty. It can be replaced by either inorder successor or an inorder predecessor.

Inorder successor of 16 nodes is the 24.

Inorder predecessor of 16 is 13.

Successor is the leftmost element in the right subtree.

Predecessor is the rightmost element in the left subtree.

Solution

Check out the function which inserts the new node after the specified node.

The correct code to insert a new node after the given prev_node is:

/* Given a node prev_node, insert a new node after the given prev_node */

void insertAfter(struct Node* prev_node, int new_data)

{

/*1. check if the given prev_node is NULL */

if (prev_node == NULL)

{

printf("the given previous node cannot be NULL");

return;

}

/* 2. allocate new node */

struct Node* new_node =(struct Node*) malloc(sizeof(struct Node));

/* 3. put in the data */

new_node->data = new_data;

/* 4. Make next of new node as next of prev_node */

new_node->next = prev_node->next;

/* 5. move the next of prev_node as new_node */

prev_node->next = new_node;

}

The function fun provided question replaces the position of line 4 by 5 and 5 by 4.

Because of this, a new node(10) will be inserted after N2, but loss of all nodes after that. Hence the linked list will lose N3 node from the given linked list.

hence because of this operation the new node will be added after N2, but the resultant data structure will not be a linked list because of loss node N3 and NULL pointed by N3 in the last.

Solution

Primitive data structures are those which are predefined way of storing data by the system. And the set of operations that can be performed on these data are also predefined.

Primitive data structures are char, int, float, double. Characters are internally considered as int and floats also falls under double and the predefined operations are addition, subtraction, etc.

But there are certain situations when primitive data structures are not sufficient for our job. There comes derived data structuers and user defined data structures.

Derived data structures are also provided by the system but are made using premitives like an array, a derived data. It can be array of chars, array of ints, etc. The set of operations that can be performed on derived data structures are also predefined.

Finally there are user defined data types which the user defines using the primitive and derived data types using language constructs like structure or class and uses according to their needs. And the user has to define the set or operations that we can perform on them.

User defines data types are LinkedLists, Trees, etc.

Solution

For an k-ary tree where each node has k children or no children, following relation holds

L = (k-1)*n + 1

Where L is the number of leaf nodes and n is the number of internal nodes.

since its a complete k tree, so every internal node will have K child

Let us see following for example for a full ternary tree.

o

/ | \

o o o

/ | \ / | \ / | \

o o o o o o o o o

k = 3

Number of internal nodes n = 4 ………………[This includes root node too]

Number of leaf nodes = (k-1)*n + 1

= (3-1)*4 + 1

= 9

Solution

Consider a doubly linked list as above.

rearmost → bwd means pointing to 3rd node

rearmost → bwd → fwd means pointing to 4th node.

When we assigning NULL to that expression that means 3rd nodes Next link is pointing to NULL. This means that 4th node is lost/ deleted from the doubly linked list.

Solution

Consider T=100, S=2 bytes

By substitution method let’s find address of

A[3] = T + (i - 1)S

= 100 + (3 - 1)2

= 100 + 2.2

= 104 = A[3]

Hence T + (i - 1)S is correct answer.

Solution

The starting vertex can be any one of the N vertices. Once the starting vertex has been chosen, the next vertex can be chosen in N-1 ways, as every other vertex is directly connected to starting vertex.

Again next vertex can be picked in (N-2) ways.

next vertex can be picked in (N-3) ways.

…

….

Last vertex can be picked in 1 way.

Total number of DFS traversals = N * (N-1) * (N-2)* (N-3)....* 1 = N!

Solution

Preorder:

Inorder:

Answer:

E M X S B P N T H C W A

Solution

X != NULL by this condition we will check whether we reached the end of the list or not body of for loop will increment X and we will go from starting node till the end and as soon as X==NULL, means we will come out of for loop.

ctr will be incremented for every node.

Solution

All give the same resultant AVL tree.

I)

II)

Solution

On the execution of first for loop, all the elements will be enqueued.

i=1 => dequeue 1, enqueue(2)

i=2 => dequeue 3, enqueue(4)

i=3 => dequeue 5, enqueue(6)

i=4 => dequeue 7, enqueue(8)

i=5 => dequeue 2, enqueue(4)

i=6 => dequeue 6, enqueue(8)

i=7 => dequeue 4, enqueue(8)

At the end of the execution only 8 will remain in the queue.

Solution

To count labeled trees, we can use above count for unlabeled trees.

T(n) = (2n)! / (n+1)!n!

Here, every unlabeled tree with n nodes can create n! different labeled trees by assigning different permutations of labels to all nodes.

Therefore,

Number of Labeled Tees = (Number of unlabeled trees) * n!

= [(2n)! / (n+1)!n!] × n!

For example for n = 3, there are 5 * 3! = 5*6 = 30 different labeled trees

Solution

Total number of distinct BST with n nodes(key)

B(5) = 1/(n+1) [2n C n]

= 1/(5+1) [10 C 5]

= ⅙ * 252

= 42

Solution

The program prints consecutive characters before ‘ ‘ or ‘*’ (whichever comes first) in reverse order.

if ((*a) && (*a != '*'))

So, the if breaks either when ∗a=0 (not '0' but ASCII 0 or null character '\0'), or when ∗a='*'.

So, the recursive call goes like

let say for the first iteration that is for value 1 print will print a + 2 = 1 + 2 = 3, again print(3) is called hence a+2= 3+2 =5.

again print(3) is called hence a+2= 5+2 =* Hence if condition is false because of *a!=*

Now prog will return to print(5) and remaining line i.e. putchar(*a) = 5 will be printedAfter this prog will return to print(3) and remaining line i.e. putchar(*a) = 3 will be printedAfter this prog will return to print(1) and remaining line i.e. putchar(*a) = 1 will be printed.

So,

'1' - '3' - '5' - '*' (breaks) and then starts outputting 531.

Hence 531