fix: Use the correct notation for all the worst-case time complexities in allhands/spring2025/weekfifteen/teamone/index.qmd.

Author: gkapfham

allhands/spring2025/weekfifteen/teamone/index.qmd

@@ -662,44 +662,54 @@ The result of the worst case time complexities are as follow:
 
 | Implementation |  Insert  |  Lookup  |  Delete  |  Verify Deletion  |
 | -------------- | -------- |--------: | -------: | ----------------: | 
-| List           | 0(n)     | 0(n^2)   | 0(n^2)   | 0(n^2)            |
-| Set            | 0(n)     | 0(n)     | 0(n)     | 0(n)              |
+| List           | $O(n)$     | $O(n^2)$   | $O(n^2)$   | $O(n^2)$            |
+| Set            | $O(n)$     | $O(n)$     | $O(n)$     | $O(n)$              |
 
 : Worst case time complexities for all operations and implementations studied in this experiment. {.responsive}
 
 ## Insert
-- Set remains at 0(n).
-- List is also 0(n) as it is  appending at the end.
-- Even though both are at 0(n), List is comparatively a lot faster than set at pure appending hence it is faster than set.
+- Set remains at $O(n)$.
+- List is also $O(n)$ as it is  appending at the end.
+- Even though both are at $O(n)$, List is comparatively a lot faster than set at
+pure appending hence it is faster than set.
 
 ## Lookup
-- Set remains at 0(n) 
-- List provide time complexity of 0(n^2) when doubling the list size.
-- Set is faster constantly for the both small and large data sizes compared to list.
+- Set remains at $O(n)$ 
+- List provide time complexity of $O(n^2)$ when doubling the list size.
+- Set is faster constantly for the both small and large data sizes compared to
+list.
 
 ## Delete
-- Set remains at 0(n).
-- List provides time complexity of 0(n^2).
-- For the smaller data both are almost similar for the deletion but as the data increases the list falls behind due to the shifting.
+- Set remains at $O(n)$.
+- List provides time complexity of $O(n^2)$.
+- For the smaller data both are almost similar for the deletion but as the data
+increases the list falls behind due to the shifting.
 
 ## Verify Deletion
-- Set remains at 0(n).
-- List provide time complexity of 0(n^2).
-- Set is faster constantly for the both small and large data sizes compared to list.
+- Set remains at $O(n)$.
+- List provide time complexity of $O(n^2)$.
+- Set is faster constantly for the both small and large data sizes compared to
+list.
 
 ## Conclusion
 
-Set is demonstrably faster than list because it uses a hash table while lists use dynamic arrays. Other than append(insert)
-which is 0(n) due to python geometrically growing capacity, List must look at every element or need to shift for other
-operations which results in 0(n^2).
-- If you need fast, random insert, delete and lookup of vertices or edges use **Set**. 
-- If you truly just need to build up nodes or neighbors and then walk them sequentially use **List**.
+Set is demonstrably faster than list because it uses a hash table while lists
+use dynamic arrays. Other than `append` and `insert`, which is $O(n)$ due to
+Python's geometrically growing capacity, `List` must look at every element or
+need to shift for other operations which results in $O(n^2)$.
+
+- If you need fast, random insert, delete and lookup of vertices or edges use
+**Set**. 
+- If you truly just need to build up nodes or neighbors and then walk them
+sequentially use **List**.
 
 # Next Steps
 
-Potential next steps could be testing the limits of the set and list approaches, or seeing the largest number of verticies they
-can handle. Also, considering that this experiment is implemented with a tree structure to avoid cycles, another next step
-could be trying to implement the same thing with a graph structure and cycle detection.
+Potential next steps could be testing the limits of the set and list approaches,
+or seeing the largest number of vertices they can handle. Also, considering that
+this experiment is implemented with a tree structure to avoid cycles, another
+next step could be trying to implement the same thing with a graph structure and
+cycle detection.
 
 # References