MUHAMMAD FAISAL

MIT 4th Semester

Al-Barq Campus (VGJW01) Gujranwala
[email protected]
Reference MCQ’s For MIDTERM EXAMS
CS502- Design and Analysis of Algorithms

1. For the sieve technique we solve the problem,

Recursively (Handsouts Page 35 Line 4)
mathematically
precisely
accurately

2. We do sorting to,
keep elements in random positions
keep the algorithm run in linear order
keep the algorithm run in (log n) order
keep elements in increasing or decreasing order (Handsouts Page 39 Line 6)

3. The reason for introducing Sieve Technique algorithm is that it illustrates a very
important special case of,
divide-and-conquer (handsouts page 34 )
decrease and conquer
greedy nature
2-dimension Maxima

4. In Sieve Technique we don’t know which item is of interest

True (handsouts page 34)
False
 5. In the analysis of Selection algorithm, we make a number of passes, in fact it could
be as many as,
T(n)
T(n / 2)
log n (handsouts page 37)
n/ 2 + n / 4

6. Divide-and-conquer as breaking the problem into a small number of pivot

Sieve
smaller sub problems (handouts page 27)
Selection

7. A heap is a left-complete binary tree that conforms to the

increasing order only
decreasing order only
heap order (handouts page 40)
(log n) order

8. Slow sorting algorithms run in, T(n^2)

T(n)
T( log n)
T(n log n) (handsouts page 40)

9. One of the clever aspects of heaps is that they can be stored in arrays
without using any .
pointers (handsouts page 40)
constants
variables
functions

10. Sorting is one of the few problems where provable bonds exits on how fast
we can sort,
upper
lower (handsouts page 39)
average log n
2nd

11. For the sieve technique we solve the problem,

mathematically
precisely
accurately
recursively (handsouts page 35)

12. Sieve Technique can be applied to selection problem?

true (handsouts page 35)
false

13. How much time merge sort takes for an array of numbers? (n^2)
T(n)
T( log n)
T(n log n) (handouts page 30)
14. For the Sieve Technique we take time
T(nk) (handouts page 34)
T(n / 3) n^2
n/3

15. Heaps can be stored in arrays without using any pointers; this is due to the
nature of the binary tree,
left-complete Repeat
right-complete tree nodes
tree leaves

16. How many elements do we eliminate in each time for the Analysis of Selection
algorithm?
n / 2 elements
(n / 2) + n elements
n / 4 elements 2 n elements

17. We do sorting to,

keep elements in random positions
keep the algorithm run in linear order
keep the algorithm run in (log n) order
keep elements in increasing or decreasing order ( page 39 Repeat)

18. In which order we can sort?

increasing order only
decreasing order only
increasing order or decreasing order Repeat
both at the same time

19. A heap is a left-complete binary tree that conforms to the

increasing order only
decreasing order only
heap order (page 40)
(log n) order

20. In the analysis of Selection algorithm, we make a number of passes, in fact it could
be as many as,
T(n)
T(n / 2)
log n (page 37)
n/ 2 + n / 4

21. A heap is a left-complete binary tree that conforms to the

increasing order only
decreasing order only
heap order (page 40)
(log n) order

22. How much time merge sort takes for an array of numbers? T(n^2)
T(n)
T( log n)
T(n log n) (page 30)
24. n the analysis of Selection algorithm, we eliminate a constant fraction of the array
with each phase; we get the convergent series in the analysis,
linear
arithmetic
geometric (page 37)
exponent

25. Sieve Technique applies to problems where we are interested in finding a single item
from a larger set of
n items (page 34)
phases
pointers
constant

26. A (an) is a left-complete binary tree that conforms to the heap order
heap (page 40)
binary tree
binary search tree
array

27. The sieve technique works in as follows

phases (page 34)
numbers
integers
routines

29. For the heap sort, access to nodes involves simple operations.
arithmetic (page 41)
binary
algebraic
logarithmic

30. The analysis of Selection algorithm shows the total running time is indeed
in n
arithmetic
geometric
linear (page 37)
orthogonal

For the heap sort, access to nodes involves simple operations. Select
correct option:
Arithmetic (page 41)
binary
algebraic
logarithmic

In Sieve Technique we do not know which item is of interest

True (page 34)
False
How much time merge sort takes for an array of numbers?
T(n^2) T(n)
T( log n)
T(n log n) (page 30)
For the heap sort we store the tree nodes in
level-order traversal (page 40)
in-order traversal pre-order traversal
post-order traversal

One of the clever aspects of heaps is that they can be stored in arrays without using any
.
Pointers (page 40)
constants
variables
functions

Sorting is one of the few problems where provable bonds exits on how fast we
can sort,
upper
lower (page 39)
average log n

A heap is a left-complete binary tree that conforms to the

Select correct option:
increasing order only
decreasing order only
heap order Repeat
(log n) order

In the analysis of Selection algorithm, we make a number of passes, in fact it could be as

many as,
T(n)
T(n / 2)
log n Repeat
n/ 2 + n / 4

The reason for introducing Sieve Technique algorithm is that it illustrates a very
important special case of,
divide-and-conquer (page 34)
decrease and conquer
greedy nature
2-dimension Maxima

The analysis of Selection algorithm shows the total running time is indeed in n,
Select correct option:
arithmetic
geometric
linear Repeat
orthogonal
The sieve technique works in as follows
Phases Repeat
numbers
integers
routines

Sorting is one of the few problems where provable bonds exits on how fast we
can sort,
upper
lower Repeat
average
log n

In the analysis of Selection algorithm, we make a number of passes, in fact it could be as

many as,
Select correct option:
T(n)
T(n / 2)
log n Repeat
n/ 2 + n / 4

For the Sieve Technique we take time

T(nk) Repeat
T(n / 3)
n^2
n/3

A (an) is a left-complete binary tree that conforms to the heap order Select
correct option:
heap Repeat
binary tree
binary search tree array

For the heap sort we store the tree nodes in

level-order traversal Repeat
in-order traversal
pre-order traversal
post-order traversal

In the analysis of Selection algorithm, we eliminate a constant fraction of the array with
each phase; we get the convergent series in the analysis,
linear
arithmetic
geometric Repeat
exponent

One of the clever aspects of heaps is that they can be stored in arrays without using any
.
Pointers Repeat
constants
variables
functions
Analysis of Selection algorithm ends up with,

T(n) (page 37)

T(1 / 1 + n)
T(n / 2)
T((n / 2) + n)

The analysis of Selection algorithm shows the total running time is indeed in n
arithmetic
geometric
Linear Repeat
Orthogonal

Question No. 1 Marks : 1

Consider the following pairs of functions
I . f(x) = x2 + 3x+7 g(x) = x2 + 10
II f(x) = x2log(x) g(x) = x3
III f(x) = x4 + log(3x8 +7) g(x) = (x2 +17x +3)2
Which of the pairs of functions f and g are asymptotic?
Only I Sure
Only II
Both I and III
None of the above

Question No. 2 Marks : 1

Execution of the following code fragment
int Idx;
for (Idx = 0; Idx < N; Idx++)
{
cout << A[Idx] << endl;
}
is best described as being
O(N) Sure
O(N2)
O(log N)
O(N log N)

Question No. 3 Marks : 1

If algorithm A has running time 7n2 + 2n + 3 and algorithm B has running time 2n2,
then
Both have same asymptotic time complexity Sure
A is asymptotically greater
B is asymptotically greater
None of others

Question No. 4 Marks : 1

Which of the following sorting algorithms is stable?
(i) Merge sort,
(ii) Quick sort,
(iii) Heap sort,
(iv) Counting Sort.

Only i
Only ii
Both i and ii
Both iii and iv Ref (Merge sort and counting sort are stable algorithms)

Question No. 1 Marks : 5

The following subroutine computes for a given number N.
compute(N)
{
If (N==1)
return 2
else
return compute(N - 1) * compute(N - 1)
}
What category of algorithmic solutions best characterizes the approach taken in this
subroutine (algorithm)?
Search and traversal (Not Sure)
Divide-and-conquer
Greedy algorithm
Dynamic Programming

Question No. 1
Assume that a given algorithm has a runtime C that depends on the size N of its
input
according to the following two formulas:
01
()
( 1) 2
if N
CN
C N if N
=
= −+> 2

Which of the following functions C(N) describes the runtime of the algorithm?
C(N) = N – 1
C(N) = (N - 1)2
C(N) = log2 N (Not Sure)
C(N) = 2(N - 1)
 Question No. 7
Let us say we have an algorithm that carries out N2 operations for an input of size
N. Let us say that a computer takes 1 microsecond (1/1000000 second) to carry out
one operation.How long does the algorithm run for an input of size 3000?
90 seconds
9 seconds (Sure)
0.9 seconds
0.09 seconds

Question No. 8
Consider the following polynomial
aknk+ak-1nk-1+………….a0 .
What is the Big –O representation of the above polynomial?
O(kn)
O(nk) (Sure)
O(nk+1)
None of the above

1. For the Sieve Technique we take time

> T(nk) (page 34)
>T(n / 3)
>n^2 >n/3

2. Sieve Technique applies to problems where we are interested in finding a single item
from a larger set of
Select correct option:
>n items (page 34)
>phases
>pointers
>constant

3. graphical representation of al-

gorithm.

> Asymptotic
>. Flowchart (rep)

4. who invented the quick sort

Hoare (1961, 1962) (click here)
5. function is given like 4n^4+ 5n^3+n what is the run time of

this

>theata(n^4) (click here )

>theata(n^3)

>theata(4n^4+ 5n^3) >

theata(4n^4+ 5n^3)

6. main elements to a divide-and-conquer

>Divide
>conquer
>combine
ALL of above (page27 )

8.T(n)={4 if n=1, otherwise T(n/5)+3n^ what is the answer if n=5

Answer is 79 (not sure)

8. Merge sort is a stable algorithm but not an in-place algorithm.

>True (page 54 )
>false

9. Counting sort the numbers to be sorted are in the range 1 to k where k is small.
>True (page 57)
>False

1Total time for heapify is:

2
Ο (log n)
Ο (n log n)
2
Ο (n log n)
Ο (log n) (page 43)

2 Solve the recurrence using iteration method and also find time complexity (Θ
notation)
T (n) = C + O (1) + T (n-1)
T (1) =1 and C is a constant.

3 If an algorithm has a complexity of 2

n + nlog 2 n + n. we could say that it has
logcomplexity
O(n)
O( n log 2n)
O(3)
O( log ( log2 n ))
2
O ( log2 n) (Not sure>click here)
 4.In RAM model instructions are executed
One after another
Parallel
Concurrent
Random (page10)

5.In selection algorithm, because we eliminate a constant fraction of the array with
each phase, we get the
Convergent geometric series (page 37)
Divergent geometric series
None of these

6. Due to left-complete nature of binary tree, heaps can be stored in

Link list
Structure
Array (page 40)
None of above

Question No: 1 ( Marks: 1 ) - Please choose one

Random access machine or RAM is a/an
_ Machine build by Al-Khwarizmi
_ Mechanical machine
_ Electronics machine
_ Mathematical model ref (Page 10)

Question No: 2 ( Marks: 1 ) - Please choose one

is a graphical representation of an algorithm
_ S notation
_Q notation
_ Flowchart ref (http://www.edrawsoft.com/flowchart.php)
_ Asymptotic notation

Question No: 3 ( Marks: 1 ) - Please choose one

A RAM is an idealized machine with random-access memory.
_ 256MB
_ 512MB
_ an infinitely large ref (Page 10)
_ 100GB

Question No: 4 ( Marks: 1 ) - Please choose one

What type of instructions Random Access Machine (RAM) can execute? Choose
best answer
_ Algebraic and logic
_ Geometric and arithmetic
_ Arithmetic and logic ref (Page 10)
_ Parallel and recursive
Question No: 5 ( Marks: 1 ) - Please choose one
What will be the total number of max comparisons if we run brute-force maxima
algorithm with n elements?
n
n2
2
n ref(Page 12) there are two loops
n
8
n

Question No: 6 ( Marks: 1 ) - Please choose one

What is the solution to the recurrence T(n) = T(n/2)+n .
_ O(logn)
_ O(n) ref(ref book page # 33)
_ O(nlogn)
_ O(n2)

Question No: 7 ( Marks: 1 ) - Please choose one

Consider the following code:
For(j=1; j<n;j++)
For(k=1; k<15;k++)
For(l=5; l<n; l++)
{
Do_something_constant();
}

What is the order of execution for this code.

_ O(n)
_ O(n3) ref (there are 3 nested for loops so it’s order isO(n3)
_ O(n2 log n)
_ O(n2)

Question No: 8 ( Marks: 1 ) - Please choose one

Consider the following Algorithm:
Factorial (n){
if (n=1)
return 1
else
return (n * Factorial(n-1))
Recurrence for the following algorithm is:
_ T(n) = T(n-1) +1
_ T(n) = nT(n-1) +1
_ T(n)= T(n-1) +n
_ T(n)=T(n(n-1)) +1 (Not Sure)
Question No: 9 ( Marks: 1 ) - Please choose one
What is the total time to heapify?
_ _(log n) ref (Page # 43)
_ _(n log n)
_ _(n2 log n)
_ _(log2 n)

Question No: 10 ( Marks: 1 ) - Please choose one

When we call heapify then at each level the comparison performed takes time
It will take  (1) ref (Page # 43)
Time will vary according to the nature of input data
It can not be predicted
It will take  (log n)

Question No: 11 ( Marks: 1 ) - Please choose one

In Quick sort, we don’t have the control over the sizes of recursive calls
_ True ref (page # 49)
_ False
_ Less information to decide
_ Either true or false

Question No: 12 ( Marks: 1 ) - Please choose one

Is it possible to sort without making comparisons?
_ Yes ref (page # 57)
_ No

Question No: 13 ( Marks: 1 ) - Please choose one

If there are _ (n2) entries in edit distance matrix then the total running time is
(1)
(n2)
(n)
(n log n)

Question No: 14 ( Marks: 1 ) - Please choose one

For Chain Matrix Multiplication we can not use divide and conquer approach
because,
We do not know the optimum k ref (page # 86)
We use divide and conquer for sorting only
We can easily perform it in linear time
Size of data is not given

Question No: 15 ( Marks: 1 ) - Please choose one

The Knapsack problem belongs to the domain of problems.
Optimization ref (page # 91)
NP Complete
Linear Solution
Sorting
Q1
Total time for heapify is:
(log2 n)
(n log n)
(n2 log n)
(log n) (page 43) repeat

Q2:_
If an algorithm has a complexity of log2n + nlog2n + n. we could say that it has
complexity
1)O(n)
2)O( n log2n) (page 106)
3)O(3)
4)O( log2( log2n )) 5)O ( log2n)

Q4
Due to left-complete nature of binary tree, heaps can be stored in Link list
Structure
Array (page 40) repeat
None of above

Q5
In selection algorithm, because we eliminate a constant fraction of the array with each
phase, we get the
Convergent geometric series (page 37)
Divergent geometric series None of these

Q#6
In RAM model instructions are executed
One after another (page 10)
Parallel
Concurrent
Random

Qus 7
Consider the following pairs of functions
I . f(x) = x + 3x+7 g(x) = x + 1022
II f(x) = x2log(x) g(x) = x3
III f(x) = x + log(3x +7) g(x) = (x48 2 +17x +3)2
Which of the pairs of functions f and g are asymptotic?
Only I not sure
Only II
Both I and III
None of the above

Q8
Execution of the following code fragment int Idx;
for (Idx = 0; Idx < N; Idx++)
{
cout << A[Idx] << endl;
}
is best described as being
O(N) sure
O(N2)
O(log N)
O(N log N)

Q9
If algorithm A has running time 7n2 + 2n + 3 and algorithm B has running time 2n2, then
Both have same asymptotic time complexity (see page 24)
A is asymptotically greater
B
None of others

Question No. 10
Which of the following sorting algorithms is stable?
Merge sort,
Quick sort,
Heap sort,
Counting Sort.
Only i
Only ii
Both i and ii
Both iii and iv
“Counting sort and merge sort are both stable algorithms “

Q11
Consider the following recurrence relation
2 if n = 0 T n( ) =?
6 (T n - 1) otherwise
Then T(2) is
? 36 not sure
72
12
None of the above

Q12
Let us say we have an algorithm that carries out N2 operations for an input of size N. Let
us say that a computer takes 1 microsecond (1/1000000 second) to carry out one
operation. How long does the algorithm run for an input of size 3000?
? 90 seconds ? 9 seconds
? 0.9seconds
? 0.09 seconds

Q13
The appropriate big ? classification of the given function. f(n) = 4n2 + 97n + 1000 is
? (n)
? (2n)
? (n2)
? (n2 log n)
Q14
Consider the following polynomial
aknk+ak-1nk-1+………….a0 .
What is the Big –O representation of the above polynomial?
O(kn)
O(nk)
O(nk+1)
None of the above

Q15
Consider the C++ program segment given below: for ( i=0 ; i < n; i++) {
for (j = 1,sum=a[0]; j < = i; j++) Sum+=a[j];
Cout<< “The sum for sub-array is<< sum;
}
The running time of the above algorithm is
n.
n log n .
log n .
n2.

Q16
Consider the following pairs of functions
I . f(x) = (x3 + x2 + x + 1)4 g(x) = (x4 +x3 + x2+ x + 1)3
II f(x) = 22x g(x) = 2x 2
III f(x) = 2x + 3 g(x) = 2x + 7
IV f(x) = log(x2 + 1) g(x) = log( x)
Which of the pairs of functions f and g are asymptotic?
Only I
Only III
Both I and II
Both III and IV

Question No. 5
Dynamic programming uses a top-down approach.
? True click here
? False

Question No. 6
The edit distance between FOOD and MONEY is
At most four (page 76)
At least four
Exact four

Question No. 7
Consider the following recurrence relation
4 if n = 1 T n( ) =?
Tn + 2
n if n is divisible by 5 ( n/ 5) 3
Then T(5) is
25 Not sure
75
79
None of the above
Question No. 10
Execution of the following code fragment int i = N;
while (i > 0)
{
int Sum = 0; int j;
for (j = 0; j < N; j++) Sum++;
cout << Sum << end; i--;
} is best described as being
O(N) Sure
O(N2)
O(log N) O(N
log N) Question

No. 11
It is impossible to design a sorting algorithm based on comparison of keys whose worst
case run time is in O(n).
? True
? False (page 55)

Question No. 12
Consider the following recurrence relation
5 if n = 1
T n( ) =? + if n is even
? 2 ( / 2) 3 Then T(8) is
61
29
13
None of the above Not sure

Question No. 13
The merge sort algorithm involves the following steps.
Recursively sort the 1st and 2nd halves separately
Merge the two-sorted halves into a sorted group.
If the number of items to sort is 0 or 1, return.
Which is the correct order of instructions in merge sort algorithm?
? (i),(ii),(iii)
? (ii),(iii),(i)
? (iii),(ii),(i)
? (iii),(i),(ii) (page 27)

Qus14
iterfib achieve an exponential speedup over the original recursive algorithm
True (page 75)
False

Q What type of instructions Random access machine can execute?

Choose best answer.
Geometric and arithmetic
Algebraic and logic
Parallel and recursive
Q Due to left complete nature of binary tree, the heap can be stored in
• Arrays (page 40)
• Structures
• Link Lis
• Stack

Q What type of instructions Random Access Machine (RAM) can execute? Choose
best
answer
Algebraic and logic
Geometric and arithmetic
Arithmetic and logic rep(Page 10)
Parallel and recursive

Q For Chain Matrix Multiplication we can not use divide and conquer approach
because,
We do not know the optimum k (page 86)
We use divide and conquer for sorting only
We can easily perform it in linear time
Size of data is not given

Q knapsack problem is called a “0-1” problem, because

?????????????????????
Each item must be entirely accepted or rejected (page 92)
?????????????????????
???????????????????????

Q word Algorithm comes from the name of the muslim author:

Abu Ja’far Mohammad ibn Musaal-Khowarizmi. (page 7)

Q al-Khwarizmi’s work was written in a book titled

al Kitab al-mukhatasar fi hisab al-jabr wa’l-muqabalah (page 7)

Q What is the total time to heapify?

• O(log n) (page 43)
• O(n log n)
• O(n2 logn)
• O(log2n)

1. For the sieve technique we solve the problem,

recursively (page 34)
mathematically
precisely
accurately
2. We do sorting to,
keep elements in random positions
keep the algorithm run in linear order
keep the algorithm run in (log n) order
keep elements in increasing or decreasing order (page 39)

3. the reason for introducing Sieve Technique algorithm is that it illustrates a very
important special case of,
divide-and-conquer (Page 34)
decrease and conquer
greedy nature
2-dimension Maxima

4. In Sieve Technique we do not know which item is of interest

True (page 34)
False

5. In the analysis of Selection algorithm, we make a number of passes, in fact it

could be as many as,
T(n)
T(n / 2)
log n (page 37)
n/2+n/4

6. Divide-and-conquer as breaking the problem into a small number of

pivot
Sieve
Smaller subproblems (page 34)
Selection

7. A heap is a left-complete binary tree that conforms to the

increasing order only
decreasing order only
heap order (page 40)
(log n) order

8. Slow sorting algorithms run in,

T(n^2) (page 39)
T(n)
T( log n)
T(n log n)

9. One of the clever aspects of heaps is that they can be stored in arrays without
using any .
pointers (page 40)
constants
variables
functions
10. Sorting is one of the few problems where provable bonds exits on how
fast we can sort,
upper
lower (page 39)
average
log n
2nd

11. For the sieve technique we solve the problem,

mathematically
precisely
accurately
recursively (page 34) Repeat

12. Sieve Technique can be applied to selection problem?

true (page 34)
false

13. How much time merge sort takes for an array of numbers?
(n^2)
T(n)
T( log n)
T(n log n) (page 40)

14. For the Sieve Technique we take time

T(nk) (page 34)
T(n / 3)
n^2
n/3

15. Heaps can be stored in arrays without using any pointers; this is due to the
nature of the binary tree,
left-complete (page 40)
right-complete
tree nodes
tree leaves

16. How many elements do we eliminate in each time for the Analysis of Selection
algorithm?
n / 2 elements (page 36)
(n / 2) + n elements
n / 4 elements
2 n elements

17. We do sorting to,

keep elements in random positions
keep the algorithm run in linear order
keep the algorithm run in (log n) order
keep elements in increasing or decreasing order (page 39) Repeat
18. In which order we can sort?
increasing order only
decreasing order only
increasing order or decreasing order
both at the same time

19. A heap is a left-complete binary tree that conforms to the

increasing order only
decreasing order only
heap order (page 40)
(log n) order

20. In the analysis of Selection algorithm, we make a number of passes, in fact it

could be as many as,
T(n)
T(n / 2)
log n (page 37) Repeat
n/2+n/4

21. A heap is a left-complete binary tree that conforms to the

increasing order only
decreasing order only
heap order (page 40) Repeat
(log n) order

22. How much time merge sort takes for an array of numbers?
T(n^2)
T(n)
T( log n)
T(n log n) (page 40) repeat

23. One of the clever aspects of heaps is that they can be stored in arrays without
using any .
pointers (page 40) Repeat
constants
variables
functions

24. n the analysis of Selection algorithm, we eliminate a constant fraction of the

array with each phase; we get the convergent series in the analysis,
linear
arithmetic
geometric (page 37)
exponent

25. Sieve Technique applies to problems where we are interested in finding a single
item from a larger set of
n items (page 34)
phases
pointers
constant
26. A (an) is a left-complete binary tree that conforms to the
heap order
heap ref (page # 40)
binary tree
binary search tree
array

27. The sieve technique works in as follows

phases ref (page # 34)
numbers
integers
routines

28. For the sieve technique we solve the problem,

recursively ref (page #35)
mathematically
precisely
accurately

29. For the heap sort, access to nodes involves simple

operations.
arithmetic ref (page # 40)
binary
algebraic
logarithmic

30. The analysis of Selection algorithm shows the total running time is
indeed in n,\
arithmetic
geometric
linear ref(page # 37)
orthogonal

For the sieve technique we solve the problem,

Select correct option:
recursively ref (page # 35)
mathematically
precisely
accurately

For the heap sort, access to nodes involves simple

operations.
Select correct option:
arithmetic ref (page # 40)
binary
algebraic
logarithmic
We do sorting to,
Select correct option:
keep elements in random positions
keep the algorithm run in linear order
keep the algorithm run in (log n) order
keep elements in increasing or decreasing order

One of the clever aspects of heaps is that they can be stored in arrays without
using any .
Select correct option:
pointers ref (page # 40)
constants
variables

A (an) is a left-complete binary tree that conforms to the heap

order
Select correct option:
heap rep
binary tree
binary search tree
array

The analysis of Selection algorithm shows the total running time is indeed
in n,
Select correct option:
arithmetic rep
geometric
linear
orthogonal

Sieve Technique applies to problems where we are interested in finding a

single item from a larger set of
Select correct option:
n items ref (page # 34)
phases
pointers
constant

Divide-and-conquer as breaking the problem into a small number of

Select correct option:
pivot
Sieve
smaller sub problems ref (page # 34)
Selection

In Sieve Technique we do not know which item is of interest

Select correct option:
True ref (page # 34)
False
How much time merge sort takes for an array of numbers?
Select correct option:
T(n^2)
T(n)
T( log n)
T(n log n) ref (page # 40)

For the heap sort we store the tree nodes in

Select correct option:
level-order traversal ref (page # 40)
in-order traversal
pre-order traversal
post-order traversal

1.For the heap sort we store the tree nodes in

level-order traversal (page 40)
in-order traversal
pre-order traversal
post-order traversal

2.One of the clever aspects of heaps is that they can be stored in arrays without
using any .
pointers (page40)
constants
variables
functions

3. Sorting is one of the few problems where provable bonds exits on

how fast we can sort,
upper
lower (page39)
average
log n

4.A (an) is a left-complete binary tree that conforms to the heap

order
heap (page40)
binary tree
binary search tree
array

5. Sieve Technique applies to problems where we are interested in finding a

Single item from a larger set of
n items (page34)
phases
pointers
constant
6.How much time merge sort takes for an array of numbers?
T(n^2)
T(n)
T( log n)
T(n log n) (page40)

7. A heap is a left-complete binary tree that conforms to the

increasing order only
decreasing order only
heap order (page40)
(log n) order

8. In the analysis of Selection algorithm, we make a number of passes, in fact it

could be as many as,
T(n)
T(n / 2)
log n (page 37)
n/2+n/4

9.The reason for introducing Sieve Technique algorithm is that it illustrates a

very important special case of,
divide-and-conquer (page34)
decrease and conquer
greedy nature
2-dimension Maxima

10.The analysis of Selection algorithm shows the total running time is indeed
in n,
arithmetic
geometric
linear (page37)
orthogonal

1.The sieve technique works in as follows

phases (page34)
numbers
integers
routines

2.Sorting is one of the few problems where provable bonds exits on

how fast we can sort,
Select correct option:
upper
lower (rep 39)
average
log n

3.In the analysis of Selection algorithm, we make a number of passes, in fact it

could be as many as,
Select correct option:
T(n)
log n (rep 37)
n/2+n/4
4.For the Sieve Technique we take time
Select correct option:
T(nk) (page34)
T(n / 3)
n^2
n/3

5.A (an) is a left-complete binary tree that conforms to the

heap order
Select correct option:
heap (page 40)
binary tree
binary search tree
array

6.For the heap sort we store the tree nodes in

Select correct option:
level-order traversal (rep 40)
in-order
traversal pre-
order traversal
post-order traversal

7.In the analysis of Selection algorithm, we eliminate a constant fraction of

the array with each phase; we get the convergent series in the
analysis,
Select correct option:
linear
arithmetic
geometric (rep37)
exponent

8.One of the clever aspects of heaps is that they can be stored in arrays
without using any .
Select correct option:
pointers (rep40)
constants
variables
functions
 Sorting is one of the few problems where provable bonds exits
on how fast we can sort,
Select correct option:
upper
lower (page 39)
average
log n

In the analysis of Selection algorithm, we make a number of passes, in fact

it could be as many as,
Select correct option:
T(n)(page 39)
log n
n/2+n/4

For the Sieve Technique we take time

Select correct option:

T(nk) (page 34
T(n / 3)
n^2
n/3

A (an) is a left-complete binary tree that conforms to the

heap order
Select correct option:

heap (page 40)

binary tree
binary search
tree array

For the heap sort we store the tree nodes in

Select correct option:

level-order traversal (page 40)

in-order traversal
pre-order
traversal post-
order traversal
In the analysis of Selection algorithm, we eliminate a constant fraction of
the array with each phase; we get the convergent series in
the analysis,

Select correct option:

linear
arithmetic
geometric (page 37)
exponent

One of the clever aspects of heaps is that they can be stored in arrays
without using any .

Select correct option:

pointers (page 40)

constants
variables
functions

Analysis of Selection algorithm ends up with,

Select correct option:

T(n) repeat
T(1 / 1 + n)
T(n / 2)
T((n / 2) + n)

The analysis of Selection algorithm shows the total running time is indeed
in n,

Select correct option:

arithmetic
geometric
linear (page 39)
orthogonal