5.6, due on October 31

Again, this section seemed straightforward enough; it's essentially just taking the things we've covered from discrete forms to continuous. A lot of it seems based in familiar calculus, using improper integrals and the Fundamental Theorem of Calculus, so that also contributes to some of the clarity.
As has usually been the case for probability and statistics so far, the most helpful thing is to see real examples that illustrate each of the definitions, theorems, etc. clearly in a way that builds intuition.

5.5, due on October 29

I feel like I have a somewhat vague overarching understanding of this section. Aside from Poisson distributions, which I've heard of but never understood, I think I understand the definitions and equations well enough. However, in spite of this vague intuition, I struggle to see how these come together in application.

The cohesive examples done in class last time were immensely helpful. Because the materials we covered in class directly related and depended on one another it was very easy to see how they came together. If we could manage something similar given this material I think it would go a long way to filling in the gaps in my understanding.

5.4, due on October 26

While recent chapters have been pretty straightforward in terms of the material, this chapter was certainly less so. I appreciate how clear and concise some of the definitions, theorems, and propositions are though. It's just a matter of figuring out how to apply them.

Something I always seem to struggle with is preimages. I almost go through phases of clarity and confusion. One thing in particularly troublesome is the probability mass function. That's something I have a hard time understanding, and would hope to see some decent examples of its use.

Midterm Prep, on due October 17

With the exam opening tomorrow, I feel comfortable with most of the material up to this point. I suspect we will be asked to show how varying data structures represent a given data set, as well as how those data structures are manipulated (deletions, insertions, balancing trees, etc.). Similarly we will probably be asked to implement certain famous algorithms (like Dijkstra's Algorithm) to find optimal solutions. Algorithms and data structures are crucially important to any programmer, and we can thus expect to be tested on them.
I am concerned, however, about being tested on the material from section 2. We very briefly covered it, and I don't understand it at all. To be honest, I didn't even do the homework, which very well may be the reason I don't understand it. Still, the reason I didn't do the homework was because everyone said it took a really long time to work on it, and I personally didn't want to spend the time on something that only seemed marginally relevant to the rest of the material we were covering at the time.

4.5, due on October 15

Having already taken CS 252, Theory of Computation, I've already had a decent exposure to P and NP problems. It's actually a shame we won't be going over Turing machines, as I really enjoyed them at the time. This is the aspect of algorithms that has always fascinated me more than anything else; it's incredible to think there are NP problems that we don't even know could be in P!

As for my concerns, I know that proofs around these types of algorithms are much less intuitive (at least they have been for me), and I hope the course will help us develop the intuition for them.

4.1, due on October 8

For a long time I've always thought of dynamic programming as this mysterious, unintuitive concept that was never really taught in computer science. However, after reading this chapter I realized that I have been taught some aspects of dynamic programming, albeit more implicitly. I still feel I lack the intuition to truly implement it effectively, but I can see myself developing that quickly as we continue.

The biggest concern I had in this section was Bellman's optimality principle. The concept itself made sense, but I struggle to wrap my head around its application in the example provided in the text.

3.4, due on October 5

I thought the fact that a heap could be represented as an array was pretty neat, as they're usually quite easy to work with. I also appreciate how deep an understanding of various data structures we're developing in this class. As familiar as I am with data structures conceptually, I still worry about being able to recall them in a job interview scenario. So these chapters are great!

The thing I was most unsure about in this chapter was the actual process for constructing a heap. I had a hard time following the idea of heapifying, and hope we'll have time in class to better solidify it.

3.3, due on October 3

This section actually did a good job of abating some of my concerns regarding BSTs and AVL trees. When I last took a course on data structures I remember being intimidated by them, but it was refreshing to find that these aren't quite as complicated as I remembered as a young CS student.

That said, AVL trees still leave me a little uneasy as to the coding implementation. I also would like to understand how to handle the third case of deleting nodes from a standard BST: when a node has two children. I'm having trouble thinking about how that would be programmed algorithmically.

3.2, due on October 1

I'm pretty familiar with stacks and queues, and this section seemed more helpful in the realm of formulas and propositions than the last. I had a hard time on the last section in some ways because we didn't have many hard and fast formulas like Poposition 3.2.7 "G is a tree if an only if |E| = n - 1".

While stacks and queues are straightforward data structures, some of the other tree structures, such as AVL trees, are pretty complicated (maybe not so much conceptually, but definitely more complicated when it comes to coding it up), so I'm not really looking forward to the next section....