Data Structures & Algorithms Roadmap - What You NEED To Learn

Summary

This video script serves as a comprehensive guide for aspiring software engineers to master data structures and algorithms. It emphasizes the importance of understanding big O notation and time complexity, then delves into various data structures including arrays, linked lists, trees, and graphs. The script also covers essential algorithms like recursion, searching, sorting, and graph traversal, before touching on advanced topics and mathematical foundations. The speaker offers resources and tips for effective learning, aiming to equip viewers with the necessary skills for software engineering roles.

Takeaways

• 📚 Data structures and algorithms are essential for aspiring software engineers, and the video provides a roadmap for learning them effectively.
• 🔍 Understanding Big O notation and time complexity analysis is fundamental, as it helps evaluate the efficiency of code and is crucial for mastering data structures and algorithms.
• 🕒 Time and space complexity are key concepts that should be thoroughly understood, as they are applicable to all areas of data structures and algorithms.
• 📈 Arrays are the starting point for basic data structures, with a focus on understanding their operations, efficiency, and the differences between dynamic and fixed-sized arrays.
• 🔗 Linked lists, both singly and doubly, are fundamental data structures where understanding node references, traversal, and operation efficiencies is important.
• 🔁 Queues and stacks are linear data structures that require knowledge of their specific operations and the efficiency of those operations in different scenarios.
• 🌳 Trees, including binary trees, binary search trees, and heaps, introduce non-linear data structures with unique properties and traversal methods.
• 🔍 Graphs are complex data structures with various properties and require understanding of representation methods and traversal techniques.
• 🔑 Hashing is an important concept for understanding the efficiency of everyday data structures like hash maps.
• 🤔 Algorithms are categorized into several types, including recursion, searching, sorting, and more advanced ones like divide and conquer, dynamic programming, and backtracking.
• 🛠️ Recursion, searching algorithms (linear and binary search), sorting algorithms (like merge sort and quicksort), and graph algorithms (depth-first and breadth-first search) are fundamental and should be deeply understood.
• 📈 Advanced data structures and mathematical topics like tries, B-trees, AVL trees, red-black trees, skip lists, segment trees, Fenwick trees, disjoint sets, and discrete math are optional for those seeking deeper knowledge but are not required for most software engineering roles.

Q & A

What is the first and most crucial topic to master when studying data structures and algorithms for software engineering?

The first and most crucial topic to master is Big O notation and time complexity analysis, which helps in understanding the efficiency of code and comparing different algorithms.

Why is it important to understand time complexity and efficiency when learning about data structures?

Understanding time complexity and efficiency is important because it translates to every area of data structures and algorithms, allowing one to choose the most efficient data structure for different types of operations.

What are the four main operations typically associated with data structures?

The four main operations typically associated with data structures are creating, deleting, inserting, and locating elements.

What is the difference between a dynamic array and a fixed size array?

A dynamic array can grow in size as needed, whereas a fixed size array has a predetermined number of elements and does not change in size.

How does a singly linked list differ from a doubly linked list?

A singly linked list allows traversal in one direction, from the head to the tail, while a doubly linked list allows traversal in both directions, with each node having a reference to both the previous and next nodes.

What are the advantages of using a queue over a stack in terms of data structure operations?

A queue maintains the order of element insertion, which is useful for scenarios where items need to be processed in the order they arrive. A stack follows the Last In, First Out (LIFO) principle, which is beneficial for scenarios like function call stacks or undo mechanisms in applications.

What are the three main types of tree traversal methods that should be understood when studying binary trees?

The three main types of tree traversal methods are pre-order, in-order, and post-order traversal.

What is a binary search tree and how does it differ from a regular binary tree?

A binary search tree is a binary tree with the property that the value of each node is greater than all values in its right subtree and less than all values in its left subtree. This differs from a regular binary tree which does not enforce any order among the node values.

What are heaps and how do they relate to priority queues?

Heaps are special tree-like data structures that satisfy the heap property, where the parent node is either greater than or equal to (in a max heap) or less than or equal to (in a min heap) the values of its children. They are used to implement priority queues efficiently.

What are some famous graph algorithms that one should be familiar with?

Some famous graph algorithms include Depth-First Search (DFS), Breadth-First Search (BFS), Dijkstra's algorithm, and A* algorithm for pathfinding, as well as Kruskal's and Prim's algorithms for finding minimum spanning trees.

What are some sorting algorithms that are fundamental to computer science knowledge?

Some fundamental sorting algorithms include Merge Sort, QuickSort, Insertion Sort, Selection Sort, Bubble Sort, and Heap Sort.

What are some advanced data structures that can be studied for a deeper understanding of computer science?

Some advanced data structures include Tries, B-Trees, AVL Trees, Red-Black Trees, Skip Lists, Segment Trees, Fenwick Trees, and Disjoint Set.

What mathematical topics can provide a deeper understanding of data structures and algorithms?

Mathematical topics such as Combinatorics, Probability, Discrete Math, and Discrete Structures can provide a deeper understanding of why certain data structures have different time complexities and how to prove the time complexity of algorithms.

Outlines

00:00

📚 Essential Data Structures and Algorithms for Software Engineers

This paragraph introduces the fundamental importance of data structures and algorithms for aspiring software engineers. The speaker outlines a structured approach to learning these topics, emphasizing the importance of understanding big O notation and time complexity analysis. The focus is on evaluating code efficiency and differentiating between linear, exponential, and logarithmic time complexities. The speaker also mentions the availability of a free text-based roadmap in their school community and encourages joining for additional resources.

05:02

🔍 Deep Dive into Time and Space Complexity

The speaker stresses the significance of mastering time and space complexity, which are crucial for understanding the efficiency of different data structures and algorithms. Time complexity is the primary focus, with big O notation being the standard for expressing efficiency. Space complexity, while related, is easier to grasp once time complexity is understood. The paragraph also introduces the basic data structures such as arrays, linked lists, and their variations, highlighting the importance of knowing their operations' efficiencies.

10:05

🌳 Exploring Non-linear Data Structures: Trees and Beyond

This paragraph delves into more complex, non-linear data structures such as trees, binary trees, binary search trees, heaps, and graphs. The speaker discusses the unique properties and operations associated with these structures, including traversal methods and the importance of understanding their time complexities. The paragraph also touches on the concept of priority queues and the application of graphs in various algorithms, setting the stage for more advanced topics.

15:08

🤖 Algorithms and Advanced Data Structures for Mastery

The speaker transitions from data structures to algorithms, starting with recursion and moving through various searching and sorting algorithms. The paragraph covers linear and binary search, different sorting techniques like insertion sort, selection sort, bubble sort, merge sort, heapsort, and quicksort. It also introduces graph algorithms like depth-first search and breadth-first search, as well as pathfinding algorithms like Dijkstra's and A*. The speaker emphasizes the importance of understanding and being able to implement these algorithms, suggesting that they form the backbone of computer science knowledge.

📘 Advanced Topics for the Curious Mind

In this paragraph, the speaker acknowledges that while most individuals may not need to venture into advanced topics, those interested in deepening their understanding can explore advanced data structures like tries, B-trees, AVL trees, red-black trees, skip lists, segment trees, Fenwick trees, and disjoint sets. Additionally, the speaker briefly mentions mathematical topics such as combinatorics, probability, discrete math, and discrete structures, suggesting these as optional but enriching areas of study.

🎓 Wrapping Up the Comprehensive Learning Roadmap

The final paragraph wraps up the video by summarizing the entire roadmap for learning data structures and algorithms. It reiterates the availability of a detailed text-based version in the school community and promotes the speaker's course with Coursera as a comprehensive resource. The speaker encourages viewers to like, subscribe, and prepare for coding interviews with the knowledge gained, while also acknowledging the optional nature of the advanced topics covered.

Keywords

💡Data Structures

Data structures are specialized formats for organizing, storing, and manipulating data. They are fundamental to computer science and software engineering, enabling efficient data handling within programs. In the video, various data structures such as arrays, linked lists, trees, and graphs are discussed, each with unique properties and efficiencies for different operations, emphasizing their importance in mastering time and space complexity.

💡Algorithms

Algorithms are step-by-step procedures to solve problems or perform tasks. They are at the core of computer programming and are essential for software engineers to create efficient and effective code. The script covers a range of algorithms from searching and sorting to more complex graph algorithms, highlighting their significance in optimizing performance and solving computational problems.

💡Big O Notation

Big O notation is a mathematical notation used to describe the upper bound of the time complexity of an algorithm in terms of the size of the input data. It helps in classifying algorithms into categories like linear, logarithmic, or exponential time complexities. The video emphasizes the importance of understanding Big O notation for evaluating the efficiency of code snippets and choosing appropriate data structures and algorithms.

💡Time Complexity

Time complexity refers to the amount of time an algorithm takes to run as a function of the size of the input. It is a critical measure of an algorithm's efficiency. The video script discusses time complexity in the context of different data structures and operations, such as adding, removing, or locating elements, and stresses the need to master this concept for effective software engineering.

💡Space Complexity

Space complexity is a measure of the amount of memory an algorithm uses in relation to the size of the input. It is as important as time complexity when assessing the efficiency of an algorithm. The video briefly mentions space complexity in the context of understanding not just time but also the memory usage of algorithms.

💡Arrays

An array is a data structure that stores a collection of elements, typically of the same type, in a contiguous block of memory. The video discusses arrays, including dynamic and fixed-size arrays, and their operations such as adding, removing, and locating elements, emphasizing the need to understand their time complexities.

💡Linked Lists

A linked list is a linear data structure where each element is a separate object, called a node, containing a reference to the next node in the sequence. The script covers singly and doubly linked lists, explaining how they manage references between nodes and the time complexities associated with their operations.

💡Binary Trees

A binary tree is a hierarchical data structure in which each node has at most two children, referred to as the left and right child. The video explains binary trees, including their properties and traversal methods like pre-order, in-order, and post-order, and their use in organizing data efficiently.

💡Binary Search Trees

A binary search tree (BST) is a binary tree with the property that the value of each node is greater than or equal to any node to its left and less than or equal to any node to its right. The video discusses BSTs as a way to maintain a sorted order of elements, allowing for efficient search, insertion, and deletion operations.

💡Graphs

Graphs are data structures consisting of nodes or vertices connected by edges. They can represent complex relationships and are used in various applications, from social networks to transportation systems. The script covers different types of graphs, such as directed and undirected, and their representations like adjacency lists and matrices, highlighting their importance in advanced computer science.

💡Hashing

Hashing is a technique used to convert a large amount of data into a smaller, fixed-size value, known as a hash code. It is fundamental to hash-based data structures like hash maps, which offer efficient data retrieval. The video mentions hashing in the context of understanding the efficiency of everyday data structures.

💡Recursion

Recursion is a programming technique where a function calls itself to solve smaller instances of the same problem. It is a powerful method used in various algorithms. The video briefly introduces recursion, explaining its components like base and recursive cases, and its application in solving problems through repetitive self-calls.

💡Searching Algorithms

Searching algorithms are used to find specific elements within a data structure. The script mentions linear search, which involves scanning each element sequentially, and binary search, which operates on sorted data and significantly reduces the search space, illustrating the importance of choosing the right algorithm based on data characteristics.

💡Sorting Algorithms

Sorting algorithms rearrange elements in a specific order, typically ascending or descending. The video lists several sorting algorithms, such as insertion sort, selection sort, bubble sort, merge sort, and quicksort, emphasizing the need to understand their time complexities and use cases for efficient data manipulation.

💡Graph Algorithms

Graph algorithms are designed to solve problems related to graph structures, such as finding paths between nodes or determining the connectivity of a graph. The script discusses depth-first search (DFS) and breadth-first search (BFS), which are fundamental for traversing and analyzing graphs, as well as algorithms for finding minimum spanning trees and shortest paths.

💡Dynamic Programming

Dynamic programming is a method for solving complex problems by breaking them down into simpler subproblems and storing the results to avoid redundant computations. It is mentioned in the video as an advanced algorithmic technique, useful for optimization problems where overlapping subproblems occur.

💡Backtracking

Backtracking is an algorithmic technique for solving problems incrementally by trying to build a solution and undoing ('backtracking') the steps if a certain condition is not met. It is briefly mentioned in the script as a type of algorithm that can be applied to problems like the N-Queens puzzle, where it is necessary to explore and abandon potential solutions.

Highlights

Data structures and algorithms are essential for aspiring software engineers.

A roadmap is provided to learn data structures and algorithms in an effective order.

Big O notation and time complexity analysis are fundamental and must be mastered.

Understanding efficiency of code is crucial for evaluating different data structures.

Space complexity is as important as time complexity once the latter is understood.

Basic data structures such as arrays, linked lists, and dynamic arrays are foundational.

Queues and stacks are fundamental data structures with specific use cases and operations.

Binary trees and binary search trees are essential for understanding tree-based data structures.

Heaps and priority queues are important for efficient data management and retrieval.

Graphs introduce non-linear data structures with various properties and representations.

Hashing is a concept crucial for understanding hash maps and their efficiency.

Algorithms are categorized and explained, including recursion, searching, sorting, and graph algorithms.

Recursion involves calling the same function within itself and requires understanding base and recursive cases.

Searching algorithms like linear search and binary search are fundamental for locating elements.

Sorting algorithms such as merge sort and quicksort are key to understanding data organization.

Graph algorithms like depth-first search and breadth-first search are vital for traversing complex structures.

Pathfinding algorithms like Dijkstra's and A* are important for finding the shortest path in graphs.

Advanced data structures like tries, B-trees, and AVL trees are for those looking to deepen their knowledge.

Discrete math and structures provide a deeper understanding but are not necessary for most practitioners.

A comprehensive course with practice exercises and quizzes is available for those seeking a complete learning package.

Transcripts

We all know that data structures and algorithms is a must know

topic for anyone wanting to become a software engineer.

So in this video, I'll break down for you exactly what you need to learn the order

in which you should learn it and give you some details

on what you should focus on for each individual topic.

I'll even share with you

some resources and tips to learn this as effectively as possible.

Now, if you want a text based version

of this road map or something to follow along with, then join my school community.

I have it in there completely for free.

We have over 8000 members in the school community.

You can join for free. The link in the description.

I look forward to seeing you there.

So let's get right into it with the first thing you absolutely need

to master, which is big on notation and time complexity analysis.

You need to understand

how to look at a piece of code and understand how efficient that code is.

Does it run in linear time?

Does it run an exponential time?

Does it run in logarithmic time?

You should understand how to evaluate that

and you should know which code is more efficient than others.

Now, it's really important that you spend a lot of time in this section

and you really get this down.

This is not something you can skip.

You need to really understand this to the point

where I can put any piece of code in front of you

and you can tell me what the time complexity of that is.

Now, usually we're going to do this in big O notation.

It's not going to be harmful to learn about big theta notation

and the other types of notation,

but oftentimes we're just going to use bigger notation.

So as long as you understand that, that's completely fine.

Now, the reason we need to know this so deeply is because this is going

to really translate to every area of data structures and algorithms.

The whole reason we use different data structures is because

of the efficiency of them for different types of operations.

So if you don't really understand time, complexity and efficiency,

it's going to be impossible to master anything else on this list.

So please spend a lot of time here.

Absolutely. Master this.

And while you're looking at time complexity, you can also look at space.

Complexity.

Now, in my eyes,

this is pretty much the same thing just applied to memory in space.

It's pretty easy to learn space complexity once you know, time complexity.

So get those down.

Time, complexity, space, complexity.

And then move into the next topic.

So now that we're masters of bigger notation and time complexity,

it's time to get into our basic data structures.

I've got a long list here.

Just bear with you. I'm going to go through them one by one.

So the first one you're going to want to look at is arrays.

Now, you've probably seen an array before, but you may not have really gone

into the details and understood the time complexity of various operations.

So here are our goals to understand what an array is, how it works,

and what the different operations are and their efficiency.

So adding an element, removing an element, locating an element, adding an element

at the front, adding an element at the back, resizing an array,

and then dynamic arrays versus fixed sized arrays.

So a dynamic array is one that can grow in size,

whereas a fixed size array is one that only has a certain number of elements.

Here, our goal should be to understand how rays work behind the scenes

and how we grow or shrink them, depending on the operations were performing.

Now, once we look at arrays, we want to start looking at linked lists.

Now, these are probably the most basic type of data structure,

and we want to understand how we create references between different nodes,

how we traverse the links list, how we add an element, how we remove an

element, and all of the different time complexity of those operations.

One thing you're going to see here is that for all of these different data

structures, what we're focused on is four main operations

creating, deleting, inserting and locating.

In some cases there's a few more, but generally

speaking, those are the four things we do with the data structure,

and we want to know

which data structures are best at what different type of operation.

So that's why we're really focusing on the efficiency of those operations.

So we know later on which data structure we should pick

for a specific problem that we're encountering.

Okay.

So once we learn singly linked lists, we're now going to learn double linked

lists.

Now, this is a linked list that goes in both directions, pretty much.

You can look it up.

You'll see exactly how it works.

And same thing with a single linked list.

We're going to want to understand how to add, remove, find

and when we would use double versus single what the advantages are.

Once we look at that, we're going to start getting into Qs and Stacks.

Now, A is a data structure that will maintain the order

in which elements are inserted.

This is just like a queue where you add line up right in a line that is a queue.

So again, we want to understand how we add, how

we delete, how we find an element, how we create a queue.

And here we'll also want to look at

how we implement a queue because the implementation

is going to dictate the time complexity of various different operations.

Now, after we learn about queue,

of course we're going to be learning about a stack.

A stack is just like a stack of plates.

Whatever goes on the top is the first thing to come off.

So the first element on is actually the last element off,

and the last element on is the first element out.

We have life the last in, first out.

That's kind of a common term here

when we're talking about something like a stack.

There's a way to say it in reverse as well.

But a stack is another data structure we're going to want to learn again,

adding elements, removing elements, how we implement it,

and when we would use a stack versus using something like a queue.

So now that we've learned about those, we're going to start getting into trees.

Now here's where it gets a little bit more complex

and we start to see some data structures that aren't quite as familiar

because they're not linear.

They're in a tree like structure now.

So this is where you'll start to see kind of some new concepts,

but it gets pretty interesting.

So the first thing we're going to look at is just basic trees,

and we're going to specifically look at a binary tree.

A binary tree is a tree in which one node can have at most two different children.

And with the binary tree,

we have a lot of different properties and ways to traverse the tree

to add an element to the tree, to remove an element to the tree to locate.

And if if an element exists or to create the tree when we're starting out.

So we're going to want to look at all of those different things.

And when we start looking at trees,

there's going to be three traverses that we're going to want to focus on

the post order, the pre order and the in order traversal.

These are very important to understand.

So make sure you spend some time once you've learned

about the basics of trees, to know how those reversals work.

Now we're also going to want to learn about some different tree properties

like the height of a tree, the depth of a node within the tree.

We're going to want to understand what a complete binary tree is,

what a full binary tree is, what a perfect binary tree is.

There's all these different properties of trees,

and even though you don't need to memorize

all of them, you should have at least seen them once.

So make sure you go through all of those different core concepts.

There's probably some I'm forgetting here,

but those are the main ones I can think of off the top of my head.

Now, once we've learned about binary trees, we're going to start learning

about binary search trees.

Now, binary search tree is very similar to what we learned before,

but in this case we use the tree to more efficiently locate elements

and we sought them or saw them story in more of a sorted order.

Now, it's not a linear sorted order like we would have seen before,

but with the binary search tree, all of the children to

the right of a parent are going to have a greater than value.

And all of the children

to the left of the parent are going to have a value less than that.

Now, this allows us to create

an efficient data structure for locating different elements,

but there's some other properties of this that we're going to want to understand,

like how do we insert an element in a binary search tree?

How do we remove an element, how do we locating element, etc..

So look at both regular binary trees and then binary search trees.

Once we look at binary search trees, we're going to start looking at heaps.

Now, heaps are similar to binary

search trees, but they work a little bit different.

And again, we're focusing on those main operations like creating

a heap, inserting, deleting, locating, etc..

Now with the heap, we're going to want to look at a min heap

and a maxy and we'll try to see how a heap can actually work.

Is something known as a priority queue, which is another data structure

that we should kind of learn about in tangent with the heap.

Now, once we learn about heaps, we're going to move on to graphs

that when we talk about graphs, we're going to be talking about

nodes or vertices that are connected with different edges.

We have so many different properties of graphs, like directed graphs,

undirected graphs, weighted graphs, unweighted graphs,

and we need to understand how to represent graphs and how to traverse them

so we could have adjacency lists, adjacency matrices, edge lists.

There's all different types of properties of graphs.

And here's where you can get into graph theory and get really, really complicated.

Start talking about cycles within graphs and all kinds of fancy algorithms.

You don't need to get too crazy here, but you want to understand what a graph is,

how you represent a graph, the different types of representations

and which is advantageous in which scenario.

Now, once we understand graphs

and we get the terminology out of the way, we're going to start looking at hashing.

Now, hashing is not overly complex.

This isn't something I would spend a ton of time on,

but we want to understand what a hash

is, how we hash and how we use this for something like a hash map.

That way we understand how some data structures that we use every single day

actually operate and the efficiency of those data structures.

So that wraps up our basic data structures.

I know this is overwhelming and it's a lot of content,

but this really is what you need to know.

Just as the basics in data structures and algorithms.

And now we're going to get into the algorithms.

All right.

So now we're going to start diving into algorithms.

But I do want to let you know that if you do want to learn all of this

and you actually want some practice

and ways to evaluate if you actually know what you're learning,

then you can check out my course with course Careers.

This is a full software development course.

It doesn't just teach data structures and algorithms,

but it has an entire section dedicated to this

where I break down all of the topics that I'm listening to you right now.

I explain everything that you need to know.

And not only that, we give you a bunch of practice exercises, quizzes, etc.

so you actually know if you're

ingesting this content and understanding what the heck we're talking about,

you can check it out from the link in the description.

With that said, though, let's get into our algorithms.

Okay, So now we've learned our data structures.

We're going to start talking about algorithms.

Now, these algorithms will use the various data structures that we talked about,

and a lot of them are just famous computer

science algorithms that you should be aware of

and you should implement or write once in your life.

So let's start going through now there's kind of

different categories of algorithms, so bear with me as I walk through them.

The first type of algorithm we're going to want to learn about is recursion.

And recursion is simply a recursion is simply.

Now recursion is simply.

If you got that horrible computer science joke, leave a comment down below.

But recursion is simply calling the same function from the same function,

so it's pretty much doing the same thing over and over.

Well, we create a recursive algorithm.

We have something known as a base case in a recursive case.

You can learn more about it.

This is not going to be an entire video on recursion.

Next, we have searching algorithms.

Now, these you may have already seen at this point, but a searching algorithm

is something we use to locate something within a data structure.

So we have a linear search, which means simply scanning something

from left to right and trying to find an element.

And then we have something like binary search, which is a way

that we can sort or source search very quickly within a sorted list.

You want to learn both of those and you should know how to implement them

and write them out.

Next, we have sorting algorithms.

Now sorting is a very famous thing in computer science.

Obviously we need to do this all the time.

So it's important to understand

these different algorithms and the efficiency of each of them

within sorting algorithms. We have so many different options.

I'm going to list a few here and if you follow

any reputable curriculum, then these will probably all be taught.

So we have insertion, sort, selection, sort bubbles,

sort merge, sort heaps, sort quicksort.

There's probably a few other things that I'm forgetting,

but those are the main famous ones that you want to be aware of.

You don't necessarily need to write all of these out.

We should understand how they work and what sorting algorithm is

used as the default implementation for a programing language.

You Right.

So next we're moving on to graph algorithms.

Now, at this point,

we really want to focus on depth first, search and breath first search

and make sure we can implement those and really understand how they work.

So with depth first search, we're using a stack with breath for search.

We're using a queue.

We want to really make sure we're good at these

because these are very famous algorithms.

They're used in a ton of different problems

now, as well as that, I'd recommend looking at crew schools algorithm

and primes algorithm for finding a minimum spanning tree.

These aren't as important, but they are pretty famous algorithms

and they can show up in

some more complicated data structures and algorithms type questions.

Moving on from our graph algorithms, we have our pathfinding algorithms.

Now, these are quite a bit different.

They are a more efficient way to find the shortest path within a graph.

In this case, we have the ACE,

our Pathfinding algorithm, and Dijkstra's algorithm.

Start with Dijkstra's. Then you can look at a star.

A star is

just a slight variation of Dijkstra's, so it's not that much more difficult

to learn.

And it can always be fun to write programs that actually model these path.

Finding algorithms.

In fact, I found those are really fun when I first learned them.

So maybe here you want to take a break and actually write out

a data structure is an algorithm visualizer

where you kind of do a pathfinding algorithm. Just an idea.

Anyways, let's move on to the next algorithms.

I'm going to go a little bit faster here.

These are important to understand, but you can really only learn them

when you apply them to a specific problem.

So as much as you can look at the theory, these are going to be more ones

you focus on when you see a problem that requires this type of solution.

Now, here we have grading algorithms.

We have divide and conquer algorithms.

This kind of a general classification, but something to be aware of.

We have dynamic programing and we have back tracking algorithms.

Now, again, kind of four categories of algorithms

that are hard to learn theoretically and that are easier

when you actually apply them into a problem.

Okay.

So that wraps up the algorithm section.

Now, it's worth noting that there are tons of different algorithms you can learn,

but these are the most famous and if I was going to name the few that

you should really focus on, they would be the following.

So linear search, binary search

depth first search breath, first search.

And then you want to understand

sorting algorithms like the merge sort and the QuickSort algorithm.

If you only had to learn a few algorithms on this list, those would be the few

I would really, really dive into and make sure you fully understand.

The reason for that is these are the most commonly used,

and I would say

they're the most fundamental in terms of computer science knowledge.

The other ones are important, don't get me wrong,

but if you're only going to learn a few of them,

really focus on those specific few.

So at this point, for 95% of you, you have all the knowledge

you need to really start practicing this.

And if you do have something like a coding interview, start preparing for

that interview by doing data structures and algorithm style questions.

However, if you really want to get to the next level,

there are some more advanced data structures

and some math you may want to learn, which I'm going to share with you now.

Now, I just want to emphasize that for most of you, you do not need to know this.

Even myself, I have not mastered these different data structures,

so I'm just going to quickly run through a list of the advanced ones.

Again, there are completely optional

that you may want to look at if you really want to get to the next level.

But keep in mind, most of you do not need to know this

and you'll be completely fine with what I said before.

Okay, so let's get into it.

Here we have tries B trees, AVL trees,

red black trees, skip lists, segment trees, Fenwick tree and the disjoint set.

Now there's about a billion other data structures I could share here as well.

But these are the more popular advanced ones.

Now, if you've learned all of that

and you really feel like punishing yourself still,

I'll give you a few math topics you can learn.

They'll give you a much deeper understanding.

But again, this is fully optional.

I've actually learned all of this math.

I can't remember any of it to this day, but I do remember when I was learning,

I was like, okay, that's kind of cool.

And now I feel like I understand this a bit better.

Anyways, we have common neutron x, we have probability discrete math

and discrete structures.

Now discrete math in discrete structures are two courses that I took in university.

I cannot tell you what I learned.

I don't remember most of it, but it was based on like mathematical proofs

and actually

going through some pretty deep math that kind of allows us to understand why

certain data structures have different time complexities,

how we actually prove the time, complexity of algorithms, etc.

not something I feel like you really need to know.

I don't think I've ever used this in real life,

but if you do really want to get into the nitty gritty,

you can learn those type of mathematical topics.

Okay, so let's get a wrap up this complete road map.

I just wanted to go through everything you need to learn.

So you have one video that has everything and you can kind of reference

this if you're looking for a road map where it got it.

Keep in mind that you have the text based version in the school community

completely free.

You can join from the link in the description

and if you want a great resource that really has all of this packaged

into one place, you can check out my course with course careers.

I'll wrap up the video here if you guys enjoy, make sure they like

subscribe the channel and I will see you in the next one.