GATE Computer Science Engineering(CSE) 2027 Test: Programming & Data Structures

In the worst case, the element to be searched has to be compared with all elements of linked list.

Asymptotic time complexity of both is of order logn.

If we take look at the inner statements of first loops, we can notice that the statements swap A[i][j] and A[j][i] for all i and j. Since the loop runs for all elements, every element A[l][m] would be swapped twice, once for i = l and j = m and then for i = m and j = l. Swapping twice means the matrix doesn’t change.

Key size = 14 bytes (given)
Child pointer = 6 bytes (given)
We assume the order of B+ tree to be ‘n’.
Block size = (n – 1) * key size + n * child pointer
512 >= (n – 1) * 14 + n * 6
512 >= 14 * n – 14 + 6 * n
n = (512 + 14) / 20
n = 526 / 20
n = 26.3
n = 26

Thus, option (C) is correct.

load factor = (no. of elements) / (no. of table slots) = 2000/25 = 80

A simple solution is to traverse the linked list until you find the node you want to delete. But this solution requires pointer to the head node which contradicts the problem statement.

Fast solution is to copy the data from the next node to the node to be deleted and delete the next node. Something like following.

// Find next node using next pointer
struct node *temp  = node_ptr->next;

// Copy data of next node to this node
node_ptr->data  = temp->data;

// Unlink next node
node_ptr->next  = temp->next;

// Delete next node
free(temp);

Time complexity of this approach is O(1)

In Open Addressing scheme sometimes though element is present we can't delete it if empty bucket comes in between while searching for that element. External hashing scheme is free from this limitations. Hence, Option c is correct answer. 

The initial solution of a transportation problem is said to be non-degenerate basic feasible solution if it satisfies:
(a)The solution must be feasible, i.e. it must satisfy all the supply and demand constraints.
(b)The number of positive allocations must be equal to m1n21, where m is the number of rows and n is the number of columns.
(c) All the positive allocations must be in independent positions.
So, option (D) is correct.

When five items: A, B, C, D, and E are pushed in a stack: Order of stack becomes: A, B, C, D, and E (A at the bottom and E at the top.) stack is popped four items and each element is inserted in a queue: Order of queue: B, C, D, E (B at rear and E at the front) Order of stack after pop operations = A Two elements deleted from the queue and pushed back on the stack: New order of stack = A, E, D(A at the bottom, D at the top) As D is on the top so when pop operation occurs D will be popped out.
So, correct option is (D).

Option A is correct. Int is the data type used,geeks is the name of the array and [20] is the size of the array.