Solution

top == SIZE-1 As SIZE-1 is the last index of the array and if top is pointing to it that means there is no room to insert any other element hence this an overflow condition and top == -1 0th index is 1st index where we can insert the 1st element in stack, if top’s value is -1 means there is no element present in the stack anymore and this is an underflow condition.

Solution

Time complexity to push an element into a stack implemented using an array is O(1).

Time complexity to push an element into a stack implemented using a linked list is O(1).

Hence the given statement is wrong

Solution

Since the stack data structure follows LIFO order. When we pop() items from stack, they are popped in reverse order of their insertion (or push())

Solution

A queue is a data structure where you do all insertions and deletions at rear and front respectively.

Solution

As data[0] is always the front the get_front() function which will get the value at front will have O(1) time complexity.

Insert and is_empty function has to traverse the entire array of size n and the time complexity will be O(n)

Insertion as usual will take O(1) time because rear will work normally and will take constant time to insert some element by incrementing the rear by 1.

The is_empty function will also take constant time,i.e, O(1) time only because we have to just check if front == rear or not. If front == rear then is_empty function will return 1 else will return 0.

But get_front() function would take linear time or O(n) time because since front always points to data[0] so front pointer cannot be moved. So to get front ,i.e. to get the first element we will have to shift each element by one towards 0th index.Then the first element will be now at index 0 and hence we can get it. So since we might have to shift n-1 elements towards 0 if the circular array of size n is completely filled. Hence O(n) or linear time will be required.

Suppose there is a circular array of n elements out of which n-1 is full (let n=7)

Now to get the first element we will shift each element towards 0.

Now we will delete the element pointed by front and set it.

FInally Circular array will be:

Since we shifted n-1 or 6 elements so get_front() function would require O(n) time or linear time.

Solution

The queue data structure is FIFO i.e. first in first out and hence the output will be zyxw.

Solution

Some facts about Function pointer:

Unlike normal pointers, a function pointer points to code, not data. Typically a function pointer stores the start of executable code.

Unlike normal pointers, we do not allocate de-allocate memory using function pointers.

Solution

fun1() prints the given Linked List in reverse manner. For Linked List 1->2->3->4->5, fun1() prints 5->4->3->2->1

Solution

An array is the data structure that contains a collection of similar type data elements whereas the Linked list is considered as a non-primitive data structure containing a collection of unordered linked elements known as nodes.

In the array the elements belong to indexes, i.e., if you want to get into the fourth element you have to write the variable name with its index or location within the square bracket.

In a linked list though, you have to start from the head and work your way through until you get to the fourth element.

Accessing an element in an array is fast, while Linked list takes linear time, so it is quite a bit slower.

Solution

/* Counts the no. of occurrences of a node

(search_for) in a linked list (head)*/

int getCount(struct Node* head)

{

// Base case

if (head == NULL)

return 0;

// count is 1 + count of remaining list

return 1 + getCount(head->next);

}

Consider a linked list of length 3:

1 -> 2 -> 3 -> NULL

^

head

First call will be in main function getCount(head),

after that getCount(1) => 1 + getCount(2) => 1 + 2 = 3

after that getCount(2) => 1 + getCount(3) => 1 + 1 = 2

after that getCount(3) => 1 + getCount(NULL) => 1+ 0 = 1

after that getCount(NULL) => return 0 => 0

Solution

Following 3-ary Max Heap can be constructed from sequence given option.

Solution

Hence no. of rotations = 1.

Solution

Solution

The inorder traversal of a BST is sorted sequence, hence inorder traversal of a given preorder traversal is: 18, 55, 58, 60, 64, 67, 79, 80, 84, 88, 90

Preorder: 67, 60, 55, 48, 58, 64, 80, 74, 84, 88, 90

Using the inorder and preorder we can derive a tree as follows:

Draw the BST from the Preorder & then write postorder.

∴ Postorder traversal of the tree is

48, 58, 55, 64, 60, 74, 90, 88, 84, 80, 67.

Solution