Data Structures and Algorithms | Set 11

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);
}

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);
}

(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 write comments if you find any of the answers/explanations incorrect, or you want to share more information about the topics discussed above.





  • Sanaya Khan

    plz plz plzzzzz some1 explain 4th ques in layman terms wid a simple example… plzzzzzzzzzzz

  • Sanaya Khan

    plz explain the 4th question

    • Guru Gorantla

      recursives will be called in the form of tree. If you take an example the way these recursive calls are made will look similar to that of a tree

      • Sanaya Khan

        plz explain it wid an example

  • hardik_tanna

    S(m) = S(m/2) + C1
    why its “C1″ constant? as per d equation its T(n)=T(sqrt(n))+n. and so it should be “S(m) = S(m/2) + m” as per your calculation and d ans comes “a” as per d master’s theorm. Please correct me if m in wrong direction.

    • GeeksforGeeks

      @hardik_tanna: Please notet tha we need to measure running time of code node value of function. Addition of a number n to a function takes constant time, that is why a constant.

  • csj

    S(m) = S(m/2) + C1

    I am not getting how did this came?? plz explain..

    • Nishant

      @csj:
      T(2^m) = S(m) // S is function of m
      so,
      S(m/2) is nothing but T(sqrt(n))=T(2^(m/2)) where n=2^m

      i hope u get it now :)

       
      /* Paste your code here (You may delete these lines if not writing code) */
       
  • http://www.CareerMonk.com Narasimha

    Looks like the recurrence related used is wrong. Used 1 instead of n.No correct option given. For the above function, the recurrence function can be given as: T(n)=T(?n)+n. Applying the logic of Problem-20, gives: S(m)=S(m/2)+2^m=2^m+2^(m/2)+S(m/4)=2^m+2^(m/2)+?+S(m/m)=2^m (1+1/2+1/4+?+1/2^m )=2^m (log2^m )=2^m m?log?_2^2=2^m m=O(nloglogn).

    -Narasimha

     
    /* Paste your code here (You may delete these lines if not writing code) */
     
    • kartik

      @Narasimha: Take a closer look at the statement. In the return statement, value of DoSomething (floor(sqrt(n))) is added to n. Adding n to a number is O(1) operation, not O(n).