- 90 Views
- Uploaded on
- Presentation posted in: General

Analysis of algorithms

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

- Best case: easiest
- Worst case
- Average case: hardest

input: 7,5,1,4,3

7,5,1,4,3

5,7,1,4,3

1,5,7,4,3

1,4,5,7,3

1,3,4,5,7

M: # of data movements in straight insertion sort

1 5 7 4 3

temporary

d3=2

best case: already sorted

di = 0 for 1 i n

M = 2(n 1) = (n)

worst case: reversely sorted

d1 = n 1

d2 = n 2

:

di = n i

dn = 0

- average case:
xj is being inserted into the sorted sequence

x1 x2 ... x j-1

- the probability that xj is the largest: 1/j
- takes 2 data movements

- the probability that xj is the second largest : 1/j
- takes 3 data movements
:

- takes 3 data movements
- # of movements for inserting xj:

1 4 7 5

- 7 5 1 4 3
1 5 7 4 3

1 3 7 4 5

1 3 4 7 5

1 3 4 5 7

- Only consider # of changes in the flag which is used for selecting the smallest number in each iteration.
- best case: (n2)
- worst case: (n2)
- average case: (n2)

- Recursively apply the same procedure.

- Best case: (n log n)
- A list is split into two sublists with almost equal size.

- log n rounds are needed.
- In each round, n comparisons (ignoring the element used to split) are required.

Worst case: (n2)

In each round, the number used to split is either the smallest or the largest.

Average case: (n log n)

- Def: A lower bound of aproblem is the least time complexity required for any algorithm which can be used to solve this problem.
☆worst case lower bound

☆average case lower bound

- The lower bound for a problem is not unique.
- e.g. (1), (n), (n log n) are all lower bounds for sorting.
- ((1), (n) are trivial)

- At present, if the highest lower bound of a problem is (n log n) and the time complexity of the best algorithm is O(n2).
- We may try to find a higher lower bound.
- We may try to find a better algorithm.
- Both of the lower bound and the algorithm may be improved.

- If the present lower bound is (n log n) and there is an algorithm with time complexity O(n log n), then the algorithm is optimal.

The worst case lower bound of sorting

6 permutations for 3 data elements

a1a2a3

123

132

213

231

312

321

- input data: (2, 3, 1)
(1) a1:a2

(2) a2:a3, a2a3

(3) a1:a2, a1a2

- input data: (2, 1, 3)
(1)a1:a2, a1a2

(2)a2:a3

- To find the lower bound, we have to find the smallest depth of a binary tree.
- n! distinct permutations
n! leaf nodes in the binary decision tree.

- balanced tree has the smallest depth:
log(n!) = (n log n)

lower bound for sorting: (n log n)

- Stirling approximation:
- n!
- log n! log n log n (n log n)

- A heap : parent son

- output the maximum and restore:
- Heapsort: construction
output

input data: 4, 37, 26, 15, 48

restore the subtree rooted at A(2):

restore the tree rooted at A(1):

Phase 2: output

- using a linear array
not a binary tree.

- The sons of A(h) are A(2h) and A(2h+1).

- time complexity: O(n log n)

- Quicksort is optimal in the average case.
((n log n) in average )

- (i)worst case time complexity of heapsort is
(n log n)

(ii)average case lower bound: (n log n)

- average case time complexity of heapsort is (n log n)
- Heapsort is optimal in the average case.