Hands-On Data Structures and Algorithms in Rust
- 7 hours on-demand video
- Full lifetime access
- Access on mobile and TV
- Certificate of Completion
Get your team access to 4,000+ top Udemy courses anytime, anywhere.Try Udemy for Business
- How Rust can help you keep your memory access safe and effective
- How we can use Rust to build Generic Algorithms that we can use again and again across our codebase
- Greedy, dynamic, and Iterative algorithms and when to use them
- Different data structures such as Maps, Trees, and Linked lists, and when it is appropriate to use them.
- Why and how an Entity Component System separates the different parts of the object into different storage areas
- How we can build files that work like simple databases using BTrees
- How we can run our programs even faster-using Multithreading
Making sure that our code does not write to something it should not, is tricky. How can we work with the Rust compiler?
• Show how an object can be copied between variables
• Show that in order to change a variable which need to make it mutable
• Show how these two features interact
Rust protects us from pointing to things that do not exist anymore. How can we work with this?
• Introduce the borrow notation for pointers
• Show how when you have a pointer to something, you cannot change it elsewhere
• Demonstrate that mutable pointers require mutable objects
What is the simplest way we can sort a list?
• See if each element should swap left in the vec
• Repeat until sorted
• Calculate how long this takes to run and if we can save time
How can we avoid performing the same calculation?
• Show how a naive fibonacci calls the same function many times
• Show how iterative solutions avoid that
• Show how by storing previously calculated results, we can save ourselves a lot of calculation
- No Rust programming knowledge is required as we will be covering the basics at the beginning.
Rust is a modern systems programming language designed with safety to simplify the development of large, complex software projects. Data structure and Algorithms are key to help in the collection and organization of the data for performing operations on the data and set instructions/logic to accomplish tasks in these projects. This course will be your guide for implementing classic data structures and algorithms in Rust, helping you to get up and running as a confident Rust programmer.
You will begin with a primer to Rust and its syntax. You will then explore the language of Time and Memory complexity by comparing different sorting methods. You’ll then learn about Lists and Binary Trees, implement them, and compare them, to show the advantages and use cases of each. Next, you will cover different algorithms in-depth such as sorting, graph, dynamic programming, greedy, divide and conquer, and more. You will learn how counterintuitive techniques can actually make it easier to build scalable projects!
By the end of the course, you will have a sound knowledge of the key data structures and algorithms in Rust to confidently implement them in your applications.
About the Author
Matthew Stoodley is a programming expert and enthusiast, who was drawn to learn about Rust and master its features initially due to its low power usage and memory safety capabilities. He primarily uses Rust to build board games.
- This course is for programmers who want to get to grips with all data structures and algorithms in the latest version of Rust programming language, to help organize your code better and accomplish predefined tasks.