This document discusses algorithms analysis and complexity including: 1) Common sorting algorithms have quadratic time complexity O(N^2) while searching algorithms can have exponential complexity like O(2^N). 2) It provides an example of determining the complexity of two functions, showing one is O(N) while the other is O(N^N). 3) Vectors in Lisp can be used to initialize a data structure of a given length by applying a function to each index, and operations on vectors have constant time complexity.

1. (VARIATION ON A THEME)

2. <<Powered by MindHD for MacOSX>>

3. -

6. EX 27.1.1
sierpinski draw-triangle, too-small?

7. 27.2 /
1. empty
2. (cons s f) : s f

8. ,
.
'NL : NewLine symbol

11. 27.3

12. TOLERANCE

14. EX 27.3.1

15. 27.4
http://en.wikipedia.org/wiki/Newton's_method

17. 27.5

18. 28

19. 28.1

22. EX 28.1.2

23. 28.2

24. 29
.
,
.

25. 29.1 ,
(Abstract Running Time)
.

27. K ,
K=2 N.

28. SORT -> N^2
N/2 -> N
insert
N -> N*N
N*N + N ->
N*N

29. MAX -> 2^N

30. 29.2 ' '
F - 1000
G -1

32. - ???
c bigEnough
bigEnough<=n f O(g)
.
f(n) <= c*g(n)
f(N) = 1000*N, g(N)=N*N
1000<=n bigEnough = 1000, c = 1
f(n) <= 1 * g(n)
f O(g)

33. max -> O(2^N)
max2 -> O(N)
.
, n->10 : max -> 2^10, max2 ->10
max2 2 , n->10 : max->2^10, max2->20
max2 2 , n->100 : max->2^100, max2->200

34. 29.3
-' '
.( , hashtable)
(build-vector N f) = (vector (f 0) ... (f (-N 1)))
(vector-ref (vector V-0 ...V-n) i) = V-i
(vector-length (vector V-0 ..V-n)) = (+ n 1)
(vector? (vector V-0 ...V-n)) = true