数据结构和算法 | 11套

以下问题已在 GATE CS 2007 考试中提出。

1. 考虑一个大小为 7 的哈希表，起始索引为零，以及一个哈希函数(3x + 4)mod7。假设哈希表最初是空的，当使用封闭哈希将序列1、3、8、10插入表中时，以下哪个是表的内容?请注意，“_”表示表中的空位置。
(A) 8, _, _, _, _, _, 10
(B) 1, 8, 10, _, _, _, 3
(C) 1, _, _, _, _, _,3
(D) 1, 10, 8, _, _, _, 3
答案 (B)
请参阅 http://lcm.csa.iisc.ernet.in/dsa/node38.html 以了解封闭散列和探测。
让我们将值 1、3、8、10 放入大小为 7 的哈希中。
最初，哈希表是空的

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

函数(3x + 4)mod 7 for 1 的值是 0，所以让我们把值设为 0

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

函数(3x + 4)mod 7 对于 3 的值是 6，所以让我们把值设为 6

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

函数 (3x + 4)mod 7 for 8 的值是 0，但是 0 已经被占用了，让我们把 value(8) 放在下一个可用空间 (1)

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

函数(3x + 4)mod 7 for 10 的值是 6，但是 6 已经被占用了，让我们把值 (10) 放在下一个可用空间 (2)

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

2. 在未加权、无向连通图中，从节点 S 到其他所有节点的最短路径的计算效率最高，时间复杂度为
(A) 从 S 开始的 Dijkstra 算法。
(B) Warshall 算法
(C) 从 S 开始执行 DFS。
(D) 从 S 开始执行 BFS。
答案(D)

* Time Complexity of the Dijkstra’s algorithm is O(|V|^2 + E)  
 * Time Complexity 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. 完整的 n 叉树是其中每个节点有 n 个孩子或没有孩子的树。设 I 为内部节点数，L 为完整 n 叉树中的叶子数。如果 L = 41，I = 10，n 的值是多少?
(一) 3
(乙) 4
(三) 5
(四) 6
答案 (C)
对于每个节点有 n 个孩子或没有孩子的 n 叉树，以下关系成立

L = (n-1)*I + 1

其中 L 是叶节点的数量，I 是内部节点的数量。
让我们找出给定数据的 n 值。

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

4. 在下面的 C函数，让 n >= m。

c

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

此函数进行了多少次递归调用?
(A) Θ(logn)?
(B) Ω(n)
(C) Θ(loglogn)
(D) Θ(sqrt(n))
答案 (A)
上面的代码是欧几里得算法的实现，用于寻找最大公约数(GCD)。
请参阅 http://mathworld.wolfram.com/EuclideanAlgorithm.html 了解时间复杂度。
5. 以下递归函数的时间复杂度是多少：

C

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

(A) Θ(n)
(B) Θ(nlogn)
(C) Θ(logn)
(D) Θ(loglogn)
答案 (D)
DoSomething() 的递归关系是

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

我们忽略了 floor() 部分，因为它是地板还是天花板在这里并不重要。

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)