Until inputs of size 100 or more, $T_2$ is the faster runtime
+
+
+
+
+
$c$ and $n_0$
+
+
Asymptotically slower runtimes can be better.
+
+
An algorithm with runtime $T_2$ is better on small inputs.
+
An algorithm with runtime $T_2$ might be easier to implement or maintain
+
An algorithm with runtime $T_1$ might not exist.
+
(sometimes we can prove this, see CSE 331)
+
+
+
+
+
+
... but from now on, if $T_2(n)$ is in a bigger complexity class, then $T_1(n)$ is better/faster/stronger.
+
+
+
+
Examples
+
+
+
+
Bubble Sort
+
+ bubblesort(seq: Seq[Int]):
+ 1. n ← seq length
+ 2. for i ← n-2 to 0, by -1:
+ 3. for j ← i to n-1:
+ 4. if seq(j+1) < seq(j):
+ 5. swap seq(j) and seq(j+1)
+
+
What is the runtime complexity class of Bubble Sort?
$n! \leq c_sn^n$ is a tight upper bound (Sterling: Some constant $c_s$ exists)
+
+
+
+
+
Bubble Sort
+
+ bubblesort(seq: Seq[Int]):
+ 1. n ← seq length
+ 2. for i ← n-2 to 0, by -1:
+ 3. for j ← i to n-1:
+ 4. if seq(j+1) < seq(j):
+ 5. swap seq(j) and seq(j+1)
+
+
Note: We can ignore the exact number of steps required by any step in the algorithm, as long as we know its complexity
+
Can we safely say this algorithm is $\Theta(n^2)$?
+
+
+
+
Bubble Sort (for Mutable Sequences)
+
+ def sort(seq: mutable.Seq[Int]): Unit =
+ {
+ val n = seq.length
+ for(i <- n - 2 to 0 by -1; j <- i to n)
+ {
+ if(seq(n) < seq(j))
+ {
+ val temp = seq(j+1)
+ seq(j+1) = seq(j)
+ seq(j) = temp
+ }
+ }
+ }
+
+
+
+
+
Bubble Sort (for Immutable Sequences)
+
+ def sort(seq: Seq[Int]): Seq[Int] =
+ {
+ val newSeq = seq.toArray
+ val n = seq.length
+ for(i <- n - 2 to 0 by -1; j <- i to n)
+ {
+ if(newSeq(n) < newSeq(j))
+ {
+ val temp = newSeq(j+1)
+ newSeq(j+1) = newSeq(j)
+ newSeq(j) = temp
+ }
+ }
+ return newSeq.toList
+ }
+
+
+
+
+
Searching Sequences
+
+ def indexOf[T](seq: Seq[T], value: T, from: Int): Int =
+ {
+ for(i <- from until seq.length)
+ {
+ if(seq(i).equals(value)) { return i }
+ }
+ return -1
+ }
+
+
+
+
+
Searching Sequences
+
+ def count[T](seq: Seq[T], value: T): Int =
+ {
+ var count = 0;
+ var i = indexOf(seq, value, 0)
+ while(i != -1)
+ {
+ count += 1;
+ i = indexOf(seq, value, i+1)
+ }
+ return count
+ }
+
+
+
+
+
Searching Sorted Sequences
+
+
... with $O(1)$ access to elements ('random access')
+
+
+
To search $[begin, end)$:
+
compare $target$ to $seq[middle]$ ($middle = \frac{end+begin}{2}$
+
If $seq[middle] = target$ return $middle$
+
If $target < seq[middle]$ search $[begin, middle)$
+
If $seq[middle] < target$ search $[middle+1, end)$
+
If $begin = end$, the value doesn't exist.
+
+
+
+
What if no random access is available?
+
\ No newline at end of file
diff --git a/src/teaching/cse-250/2022fa/slide/7b-ADTsandSequences.erb b/src/teaching/cse-250/2022fa/slide/7b-ADTsandSequences.erb
new file mode 100644
index 00000000..969a449e
--- /dev/null
+++ b/src/teaching/cse-250/2022fa/slide/7b-ADTsandSequences.erb
@@ -0,0 +1,196 @@
+---
+template: templates/cse250_2022_slides.erb
+title: Asymptotic Notation Examples
+date: Sept 16, 2022
+textbook: "Ch. 7.1, 1.7.2"
+---
+
+
+
+
+