One More Byte CS Devlog

     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.

 This week we continued with brute force techniques including an example involving string matching. This was a helpful illustration of how brute force algorithms work in practice and also showed that the worst case scenario for an algorithm is not always as obvious as it may initially seem. Lectures then covered several classic example problems like the traveling salesman problem, knapsack problem, and assignment problem which demonstrated how different types of problems often require different algorithmic approaches. We also went into more depth on the graph traversal techniques depth first Search (DFS) and breadth first search (BFS). While these concepts were a review for me, the information was valuable because it introduced new perspectives on analyzing their time efficiency. Later in the lectures we covered the divide and conquer algorithms and the master theorem, including on how to identify the time complexity of recursive problems using this method.  The week’s homewo...

     This week we focused on understanding different ways to analyze algorithm efficiency using Big O, Big Theta, and Big Omega notation. We discussed how each notation is used to describe algorithm behavior. Specifically how and when Big Theta is the most appropriate choice when compared to Big O. This helped understand why we might provide a tight bound versus an upper bound when analyzing an algorithm.      Later we took a look at recursive algorithm analysis, including using backward substitution to determine time complexity for recursive algorithms. We also learned about the brute force technique and how it solves problems by exhaustively checking all possible solutions.      I enjoyed the homework for this week, as it gave me a great opportunity to reevaluate my approach and helped me to practice writing more efficient solutions rather than settling for the first one that worked.

     This week much of what we went over is review, but good review none the less. Lectures included discussing what an algorithm is, how to write pseudocode, identifying graphs and different graph types, and algorithm analysis such as complexity and comparing the efficiency of different approaches.      Revisiting these ideas was a great refresher for the importance of using algorithms to your advantage. Alongside the lectures were fun word problems that encouraged us to think through solutions and view them through an algorithmic lens. These problems made the material more engaging and highlighted how algorithms can be used to solve complex problems efficiently in real world scenarios.