hey everyone, welcome back, and today let's do something a little bit different. Let's talk about the top six coding interview concepts that you need for interviews, and by top six, I mean the top six most common, at least in my experience. I think some people might disagree with a couple of these, but overall, these are definitely not controversial. I think generally speaking, these are six of the most common, you know, things that come up in interviews, and spoiler alert, dynamic programming is not gonna show up on my list. For how difficult dynamic programming is and how much it's talked about, it actually doesn't show up that much in interviews. I think it's kind of funny. People spend so much time studying that because they think it's really difficult, and they feel like it's definitely going to show up in their interview. Well, chances are, it's actually not going to show up in your interview. There's a lot of companies that have actually banned asking dynamic programming questions, and even the ones that do ask it don't ask it super frequently. So, I think your time

would be better invested studying some of these other more common patterns and concepts. And definitely feel free to let me know if you'd like to see more videos like this or maybe other videos. I've seen a lot of suggestions for people asking about my Google interview experience and other videos like that, so feel free to suggest it. But okay, now let's get into the top six list. Let's start with number six, and that is going to be a data structure called a heap. You may or may not be familiar with heaps, but they are a very common data structure that comes up. There's some problems where actually the entire problem itself is just using a heap, like, okay, you know, there's some operation you're trying to do. Maybe you're trying to get the minimum value or the maximum value, or one problem that comes up very frequently is the top k values or something like that. And that's really what a heap is designed to do, because with a heap, there's two variations: a minimum heap and a maximum heap. If you were doing a minimum heap

for example, you could get the minimum value from the heap in big O of one time, which is very efficient. But when it comes to actually popping that minimum value or adding a value to a heap, that is done in log n time, which is also very efficient. One thing about the heap that I see a lot of people get wrong, and even I've had interviews where the interviewer didn't know this and it was kind of an awkward situation because I was trying to explain my solution, but it's that if you're building a heap, you have 10 values or n values, let's say, and you're building a heap, you can build that heap in big O of n time as long as you have all the values available from the start. You can build the heap in big O of n time. But if you're actually manually adding each value to the heap, you don't have them available all at once, but you have to like, you know, go through some kind of data stream to add each value to the heap, then that will

take n log n time because adding a value to a heap is log n. If you have to do that n times, that's how you're going to get that time complexity. But heaps actually also show up in a lot of standard algorithms like graph algorithms, shortest path algorithms, and things like that. So, I think it's a very, very good data structure to definitely understand because the implementation is a little bit complex, but usually, you don't have to implement a heap. You can just use it, and it's very easy to use this data structure. Okay, next up is sliding window. When I actually first learned this algorithm, I didn't even know it was a standard algorithm. I was just doing some leak code problems. I couldn't figure out the problem, so I looked at the solution and saw, Okay, there's this algorithm where you use two pointers to iterate through an array. And I remember thinking, Wow, this is a really clever technique. If only I had known that it's actually a very standard algorithm, it would actually have been easier to understand because this is the type of algorithm.

you can memorize and then apply it in many, many different places. The idea is usually that you know to solve some problem, you have to iterate through an array n times. So, if you have to do that n times, the overall time complexity becomes n squared. But there's a lot of problems where you can have two pointers and then use them kind of intelligently, and in that way, you only end up iterating through the entire array once. Well, twice if you count the two pointers, but that's still big O of n time. You don't have to do nested for loops with a sliding window; you just keep track of two pointers, you increment them in an intelligent way, and then you get a very efficient algorithm. We've done a ton of sliding window problems on this channel, so definitely take a look at the sliding window playlist if you want to see some examples. The next algorithm is going to be binary search. I think every CS major will learn this algorithm and usually think it's pretty simple, at least conceptually, right? The whole idea comes

from you know if you were guessing a number between one and a hundred, and you got some kind of feedback, right? Like if you got the wrong answer, you knew if it was too high or too low. Of course, if you were guessing between 1 and 100, you would guess 50 because if it was too big, then you would eliminate all the numbers that are smaller than 50. If it's too small, then you'd eliminate all the values larger than 50 and then just continue to do that, just take the halfway point between whatever you're trying to determine. So, in that sense, it's a very simple algorithm. Usually, binary search problems are really obvious that you're supposed to use binary search. You're given some kind of array and you have to search for a value. Usually, you can search for that value in big O of n time, which you might think is efficient, but if there's a more efficient algorithm using binary search, log n is actually a lot more efficient than big O of n, which is why binary search is

you know an important algorithm, but there's also a lot of problems that are easy once you know that you're supposed to use binary search, but it's not obvious that you are supposed to use binary search. Sometimes there's a lot of data structures involved, there's a lot of things going on. You might think it's a sliding window problem, but in actuality, it's a binary search problem. So I think that's kind of the hard part about binary search, sometimes even identifying the problem needs binary search. We've also solved a lot of binary search problems on this channel if you want to take a look at the playlist for that. Okay, next up is going to be actually two algorithms that are very similar, depth-first search and breadth-first search. These are two incredibly common algorithms, probably the most common algorithms you'll use in coding interviews because they can be applied in so many different places. They can be applied to trees, but they can also be applied to general graphs, whether it's a 2D matrix type graph or a graph of nodes.

and edges, and DFS and BFS are actually the building blocks for more complex algorithms. Things like Dijkstra's algorithm, shortest path, Kruskal's, Prim's algorithm, Bellman-Ford, right? Most graph algorithms build on top of DFS and BFS. So, if you have a very good understanding of DFS and BFS, you can actually solve a very large number of problems, not just graphs, but also trees and even more. And I would say if you can get to the point where you can write a DFS algorithm or BFS in your sleep, you're going to be in very good shape for coding interviews because these are very standard algorithms. Once you've written them so many times, it becomes like second nature. But when you're a beginner, these algorithms can be pretty daunting to learn. We do have a trees playlist and a graph playlist on the channel if you want to practice some DFS or BFS. Okay, next up is recursion. Recursion was super difficult for me when I learned it back in college, but now it's actually very intuitive, just like DFS and BFS.

recursion is applied in so many places, and it's also used in graphs as well as many other categories like backtracking, sometimes with dynamic programming if you're talking about the memoization solution, and in so many other ways. Recursion is just a huge category. I don't know how you would even prepare for coding interviews if you didn't know recursion, and I definitely recommend getting pretty proficient with recursion. You definitely want to have a good understanding of the base case, the recursive step, and just the general idea of what's going on with the recursion. You should understand that recursion does take extra memory to do; it's not free. You should understand how what's going on with the call stack as you do recursive algorithms. And I think this category is probably one of the most difficult for people to learn. I think recursion is the reason why people think graphs are hard, trees are hard, backtracking is hard. It's usually because they don't have a very good understanding of recursion. Okay, last up, the number one pattern I think you

should understand for coding interviews is definitely hashmaps. It's the most simple thing on this list probably, but it's also the most common. There are so many problems that can literally just be solved by using a hashmap. The famous problem is probably twosome, because instead of iterating through the entire array to search for a matching value with twosome, you can just literally use a hash map. That's the entire problem. If you use a hashmap, then you solve it efficiently. And the important thing to know about a hashmap is basically that every operation that you do on it, pretty much any operation at least, can be done in big O of one time, in constant time. Now technically, that's not true in that technically it's amortized, because there's a lot of different ways to implement a hashmap under the hood. But basically, on average, it'll take big O of one time, and usually 99% of the time in real interviews, people will just say, Okay, yeah, it takes big O of one time to do that in a hashmap. You don't really

need to get too technical with it. Adding, removing, and searching for values in a hashmap is very efficient, and even in a lot of the other categories I was talking about, DFS, recursion, and sliding window, hash maps actually come in handy for those as well. So even if the hashmap itself won't solve the entire problem, hash maps are always used as utility data structures to do things efficiently. If you don't have a good understanding of hash maps or know how efficient they are, then pretty much any coding interview problem is going to be challenging for you. So those are the top six coding interview concepts I think you should be preparing for. Let me know if you think there's anything that I missed or there's anything that you disagree with. Of course, I could have made this list a lot longer, but I like to be concise, and I think if you are preparing for your coding interviews and you don't feel like you have a really good understanding of the six things that I talked about here, definitely recommend studying that before you get

into more complex things like dynamic programming, or getting into those really advanced and obscure algorithms like KMP pattern matching, or maybe Kruskal's algorithm, which most likely you're probably not going to see in a real coding interview. You're more likely to see the things that I talked about here. As always, thank you so much for watching. Don't forget to like and subscribe if you found this helpful. It really helps the channel a lot. Consider checking out my Patreon if you'd like to further support the channel, and hopefully, I'll see you pretty soon. Thanks for watching.

Top 6 Coding Interview Concepts (Data Structures & Algorithms)

Top 6 Coding Interview Concepts (Data Structures & Algorithms)