One More Byte CS Devlog

     This week we first covered counting sort and radix sort. I was especially impressed by the design of radix sort because of how elegant and efficient it is when applied in the right context. It was interesting to see how a noncomparison based sorting algorithms was able to outperform the traditional approaches.      We then moved into dynamic programming. At first, I found the concept somewhat confusing because it did not immediately seem different from simply working through a problem step by step. However, it eventually clicked during the homework that dynamic programming is about intentionally breaking a complex problem into smaller, manageable subproblems, solving each of them once, and then combining their results to build the final solution efficiently. Using this, I was able to pull apart the coin problem logic into smaller pieces and recombine it once each part was solved.      After that, we covered the coin-row problem and work...

     This week started with covering AVL trees and 2-3 trees. At first the order of operations required to properly rebalance and maintain these trees after insertions or deletions was a bit tricky to follow but carefully working through the videos and demonstrations helped clarify the rotation and restructuring processes. Seeing multiple examples made it much easier to understand how these self balancing trees maintain structure.      After that was heaps, how to identify them, how to construct them while maintaining heap properties, and how heap sort works. The progression from understanding heap structure to applying it in heap sort helped connect the conceptual sides of the topic. The final lectures this week focused on hashing and hash tables. I found hashing interesting because the overall concept feels intuitive, which made the material easier to grasp while still demonstrating how powerful hash tables can be for achieving efficient lookups.  ...

       This week, we covered the quicksort algorithm along with the median of three selection technique that helps improve efficiency and reduce the likelihood of worst case scenarios. We also reviewed binary tree concepts such as height and traversals. While binary tree traversals were a review for me, it was still nice to revisit them and reinforce that knowledge.      We then moved on to binary search and the decrease and conquer strategy, focusing on how breaking problems down in smaller pieces can lead to increased efficiency. One of the most interesting topics this week was directed acyclic graphs and their sorting method. The process of removing source nodes and repeatedly identifying new source nodes felt very intuitive and made the idea of topological sorting easy to understand.       Finally, we discussed the usefulness of presorting and how it can greatly improve algorithm complexity by allowing more efficient approaches...

This week was primarily focused on preparing for the midterm exam. This involved reviewing all of the material we have covered so far. Going back through the concepts helped me identify areas where I could improve, particularly reading and writing pseudocode and analyzing the efficiency of algorithms based on that pseudocode. Recognizing this gave me direction in what area I should focus my study. I especially enjoy exams that allow the use of a written study guide. The process of creating it helps cement the material in my memory. I often find that by the time I finish preparing the guide, I don’t need to rely on it as much as I initially expect. While I was nervous, as I usually am before exams, the structured review and preparation made me feel more confident going into the midterm.