f(n) is in O(g(n)) iff there exists C and N such that f(n) <= c * g(n) for all n >= N

```
W_{rev}(n) where n is the length of the argument
W_{rev}(0) = C_0
W_{rev}(n) where n > 0
W_{rev}(n) = C_1 + W_{rev}(n-1) + W_{append}(n-1, 1) (cite: spec. of rev)
<= C_1 + W_{rev}(n-1) + C_2 * n (cite: complexity of append)
= C_1 + (C_1 + W_{rev}(n-2) + C_2 * (n-1)) + C_2 * n
= C_1 * n + C_2 * (n + (n-1) + ... + 1) + C_0
= C_1 * n + C_2 * (n(n+1)/2) + C_0
= (n^2 + n)(C_2/2) + C_1 * n + C_0
So rev X runs in O(n^2) work, where n = length of x
```

```
(* trev: (int list * int list) -> int list
REQUIRES: true
ENSURES: trev (L, acc) ~= rev L @ acc
*)
fun trev ([]: int list, acc : int list): int list = acc
| trev (x::xs, acc) = trev (xs, x::acc)
W_{rev} (n, m) where n, m are the length of the arguments
W_{rev} (0, m) = C_0 (for all m)
W_{rev} (n, m) = C_1 + W_{rev} (n-1, m+1) (for all n> 0, all m)
=== Solving it ===
W_{rev} (n, m) = C_1 + W_{rev} (n-1, m+1)
= C_1 + C_1 + W_{rev} (n-2, m+2)
= k * C_1 + W_{rev} (n - k, m + k) for k = n
= n * C_1 + W_{rev} (0, m + n)
= n * C_1 + C_0
O(n)
```

```
datatype tree = Empty | Node of tree * int * tree
(*sum: tree -> int
REQUIRES: true
ENSURES: sum t |-> sum of the ints in T
*)
fun sum (Empty : tree) : int = 0
| sum (Node (l, x, r)) = sum l + x + sum r
W_{sum}(n) where n is the number of node in the tree
W_{sum}(0) = C_0
W_{sum}(n) = C_1 + W_{sum}(n_l) + W_{sum}(n_r) (for n > 0)
where n_l are number of left tree node
where n_r are number of right tree node
and n_l + n_r = n - 1
W_{sum}(n) = C_1 * n + C_0 * (n-1) (since number of leaf is the 1+ number of node)
= (C_1 + C_0) * n + C_0
O(n)
```

```
S_{sum} (0) = C_0
S_{sum} (n) = c_1 + max(S_{sum}(n_l), S_{sum}(n_r)) (for n > 0)
=== Solving it ===
If balanced: S_{sum} (n_l) = S_{sum} (n_r) = (n-1)/2
S_{sum}(n) <= C_1 + S_{sum}(n/2)
<= C_1 + C_1 + ... + C_1 + C_0
= C_1 * log(n) + C_0
O(log(n))
If perfectly unbalanced: n_l = n - 1, n_r = 0
S_{sum}(n) = C_1 + S_{sum} (n-1) (assume larger input take more running time when we solve max, using monatonity)
= n*C_1 + C_0
O(n)
```

```
S_{sum}(d) where d is the depth of the input
S_{sum}(0) = C_0
S_{sum}(d) <= C_1 + max(S_{sum}(d-1), S_{sum}(d')) with d>0, d'<=d-1
= C_1 + S_{sum}(d-1)
= d * C_1 + C_0
O(d)
```

```
(* ins: int * int list -> int list
REQUIRES: L is sorted
ENSURES ins(x, L) \-> a sorted permutation of x::L
*)
fun ins (x, []) = [x]
| ins (x, y::ys) = case compare (x, y) of
GREATER => y :: ins (x, ys)
| _ => x :: y :: ys_
fun isort ([] : int list) : int list = []
| isort (x :: xs) = ins (x, isort(xs))
W_{ins} (0) = C_0
W_{ins} (n) <= C_1 + W_{ins} (n-1)
= n * C_1 + C_0
W_{ins}(n) = O(n)
S_{ins}(n) = O(n)
W_{isort} (n) = C_1 + W_{isort} (n-1) + W_{ins} (n-1) <= C_1 + W_{isort} (n-1) + (n-1)*C_2
W_{isort} is O(n^2)
S_{isort} is O(n^2)
```

Table of Content