Software Development - Clean Code, Data Structures, and Algorithms

Readings and Resources:

Required Reading:

Lecture:

• Algorithms and Data Structures with Python

Exercise:

• Guide to Competitive Programming

Tutorial:

• Programming Rust

Additional Resources

• Rust Book, Brown University with great quizzes: https://rust-book.cs.brown.edu/
• Rust by Example: https://doc.rust-lang.org/rust-by-example/index.html
• Algorithms and Data Structures in Rust (Second half)

Required Preparation before 1st Day of Class

• Walk through the rustlings tutorial: https://github.com/rust-lang/rustlings
• Finish all Exercises for Session 1 in Rust

Competitive Programming Deliverables

In each exercise we will attempt a challenging algorithmic problem from the CSES Problemset

Class Design - Flipped Classroom

The course is taught in a Flipped Classroom style. You are required to prepare coding exercises and will be asked to present them in front of class on a random selection basis.

• 30 min | Review and joint development of selected Homework Exercises
• 60 min | Theoretical input on computational thinking with Algorithms and Data Structures.
• 90 min | Applying theoretical input in a hands-on class project: Building the Game of Clack (https://github.com/dominikb1888/clap).

Exam (graded)

The Exam will be written and online. It will be a code exercise just like the ones you practice with tests provided.

Agenda

1. Algorithms Analysis, Design and Evaluation (Chapter 2)
2. Recursion
3. Sequences
4. Sets and Maps
5. Trees
6. Graphs
7. Membership Structures
8. Heaps
9. Balanced Binary Search Trees
10. B-Trees
11. Heuristic Search

Deliverables

| Prepare before | Exercise | Topic | | 2 | Tower of Hanoi | Recursion | | 3 | Increasing Array | Dynamic Arrays | | 4 | Two Sets | Sets | | 5 | Subordinates | Trees | | 6 | Counting Rooms | Graphs | | 7 | | Bloom Filters | | 8 | | Heaps | | 9 | | Balanced Binary Search Trees | | 10 | | B-Trees | | 11 | | Heuristic Search |

Sessions

1. Algorithms: Analysis, Design, and Evaluation

Reading:

• https://nnethercote.github.io/perf-book/introduction.html
• https://towardsdatascience.com/benchmarking-rust-compiler-settings-with-criterion-62db50cd62fb
• https://patrickfreed.github.io/rust/2021/10/15/making-slow-rust-code-fast.html
• Last resort - Assembly Output: https://rust.godbolt.org/, https://darkcoding.net/software/underrust-rust-assembly-output/

2. Recursion

3. Sequences

Recap:

• Rust Memory Allocation and Pointers

Data Structures:

• Linked Lists: Improving on our Exercise
• Doubly Linked Lists
• Skip Lists
• Dynamic Arrays (Vec):

Algorithms for Sorting and Ordering:

• Bubble Sort
• Merge Sort (Divide and Conquer)
• Quicksort

Further Reading:

• https://rust-unofficial.github.io/too-many-lists/

4. Recursion

• TODO

5. Maps and Sets

Algorithms:

• Hashing

Data Structures:

• Maps
• Sets

Reading:

• https://nnethercote.github.io/perf-book/hashing.html#:~:text=The%20default%20hashing%20algorithm%20is,short%20keys%20such%20as%20integers
• https://en.wikipedia.org/wiki/Collision_attack
• https://link.springer.com/chapter/10.1007/978-3-642-34931-7_28
• https://www.reddit.com/r/rust/comments/52grcl/comment/d7kcei2/
• https://betterprogramming.pub/implementing-a-hashmap-in-rust-35d055b5ac2b

6. Trees

Data Structure:

• Heap
• Binary Search Tree
• Red-Black Tree
• Trie
• B-Tree

Algorithms

• Heap Sort

7. Graphs

• Graph Representation: Adjacency Matrix

8. Membership Structures

9. Heaps

10. Balanced Binary Search Trees

11. B-Trees

12. Heuristic Search

Further Reading

• The Rules of Programming