Following questions have been asked in GATE CS 2007 exam.

1. Consider a hash table of size seven, with starting index zero, and a hash function (3x + 4)mod7. Assuming the hash table is initially empty, which of the following is the contents of the table when the sequence 1, 3, 8, 10 is inserted into the table using closed hashing? Note that ‘_’ denotes an empty location in the table.

(A) 8, _, _, _, _, _, 10

(B) 1, 8, 10, _, _, _, 3

(C) 1, _, _, _, _, _,3

(D) 1, 10, 8, _, _, _, 3

Answer (B)

Please see http://lcm.csa.iisc.ernet.in/dsa/node38.html for closed hashing and probing.

Let us put values 1, 3, 8, 10 in the hash of size 7.

Initially, hash table is empty

- - - - - - - 0 1 2 3 4 5 6

The value of function (3x + 4)mod 7 for 1 is 0, so let us put the value at 0

1 - - - - - - 0 1 2 3 4 5 6

The value of function (3x + 4)mod 7 for 3 is 6, so let us put the value at 6

1 - - - - - 3 0 1 2 3 4 5 6

The value of function (3x + 4)mod 7 for 8 is 0, but 0 is already occupied, let us put the value(8) at next available space(1)

1 8 - - - - 3 0 1 2 3 4 5 6

The value of function (3x + 4)mod 7 for 10 is 6, but 6 is already occupied, let us put the value(10) at next available space(2)

1 8 10 - - - 3 0 1 2 3 4 5 6

2. In an unweighted, undirected connected graph, the shortest path from a node S to every other node is computed most efficiently, in terms of time complexity by

(A) Dijkstra’s algorithm starting from S.

(B) Warshall’s algorithm

(C) Performing a DFS starting from S.

(D) Performing a BFS starting from S.

Answer(D)

* Time Comlexity of the Dijkstra’s algorithm is O(|V|^2 + E) * Time Comlexity of the Warshall’s algorithm is O(|V|^3) * DFS cannot be used for finding shortest paths * BFS can be used for unweighted graphs. Time Complexity for BFS is O(|E| + |V|)

**3. A complete n-ary tree is a tree in which each node has n children or no children. Let I be the number of internal nodes and L be the number of leaves in a complete n-ary tree. If L = 41, and I = 10, what is the value of n?**

(A) 3

(B) 4

(C) 5

(D) 6

Answer (C)

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

L = (n-1)*I + 1

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

Let us find out the value of n for the given data.

L = 41 , I = 10 41 = 10*(n-1) + 1 (n-1) = 4 n = 5

**4. In the following C function, let n >= m.**

`int` `gcd(n,m) ` `{ ` ` ` `if` `(n%m ==0) ` `return` `m; ` ` ` `n = n%m; ` ` ` `return` `gcd(m,n); ` `} ` |

*chevron_right*

*filter_none*

**How many recursive calls are made by this function?**

(A) Θ(logn)?

(B) Ω(n)

(C) Θ(loglogn)

(D) Θ(sqrt(n))

Answer (A)

Above code is implementation of the Euclidean algorithm for finding Greatest Common Divisor (GCD).

Please see http://mathworld.wolfram.com/EuclideanAlgorithm.html for time complexity.

**5. What is the time complexity of the following recursive function:**

`int` `DoSomething (` `int` `n) ` `{ ` ` ` `if` `(n <= 2) ` ` ` `return` `1; ` ` ` `else` ` ` `return` `(DoSomething (` `floor` `(` `sqrt` `(n))) + n); ` `} ` |

*chevron_right*

*filter_none*

(A) Θ(n)

(B) Θ(nlogn)

(C) Θ(logn)

(D) Θ(loglogn)

Answer (D)

Recursive relation for the DoSomething() is

T(n) = T(√n) + C1 if n > 2

We have ignored the floor() part as it doesn’t matter here if it’s a floor or ceiling.

Let n = 2^m, T(n) = T(2^m) Let T(2^m) = S(m) From the above two, T(n) = S(m) S(m) = S(m/2) + C1 /* This is simply binary search recursion*/ S(m) = O(logm) = O(loglogn) /* Since n = 2^m */ Now, let us go back to the original recursive function T(n) T(n) = S(m) = O(LogLogn)

**Please see GATE Corner for all previous year paper/solutions/explanations, syllabus, important dates, notes, etc.**

Please write comments if you find any of the answers/explanations incorrect, or you want to share more information about the topics discussed above.

## Recommended Posts:

- Data Structures and Algorithms | Set 31
- Data Structures and Algorithms | Set 37
- Data Structures and Algorithms | Set 28
- Data Structures and Algorithms | Set 32
- Data Structures and Algorithms | Set 29
- Data Structures and Algorithms | Set 27
- Data Structures and Algorithms | Set 30
- Data Structures and Algorithms | Set 36
- Data Structures and Algorithms | Set 38
- Data Structures and Algorithms | Set 26
- Data Structures and Algorithms | Set 33
- Data Structures and Algorithms | Set 1
- Data Structures and Algorithms | Set 17
- Data Structures and Algorithms | Set 15
- Data Structures and Algorithms | Set 14
- Data Structures and Algorithms | Set 13
- Data Structures and Algorithms | Set 12
- Data Structures and Algorithms | Set 10
- Data Structures and Algorithms | Set 9
- Data Structures and Algorithms | Set 8