Table of contents
1. Introduction to LeetCode
2. The main purpose of brushing leetcode
3. Commonly used data structures
4. Commonly used algorithm ideas
5. Choosing algorithm questions
1. Choice of the question
2. How to write questions
Method 1: Sequence method
Method 2: Label method
Method 3: Random method
Method 4: The method of killing
6. Question-making strategy
TIP 1：
TIP 2：
TIP 3：
TIP 4：
Fresh graduate interview algorithm takes an arrayBinary TreeMatrix Arrays test your sorting in different ways Query Pointers Bit operation Linked lists test your pointer at most, at most, then have a hash test. Binary trees test recursion and traversal before, middle and back, at most, add backtracking. For matrix, it is a path query that knows the starting point and a path query that doesn’t know the starting point. It’s easier to master these areas. In fact, it has little to do with academic qualifications and technology. Most people die first and dare not think about it.
one,LeetCodeIntroduction
It is understood that LeetCode is a very good OJ (Online Judge) platform that collects interview questions from many companies. Compared with other OJ platforms, it has the following advantages:
- All questions come from real interviews from large companies in the industry
- No need to deal with input and output, all your energy is to solve specific problems
- There are rich discussions on the topic, and you can refer to other people's ideas.
- Observe the ranking of your own code in all submission codes
- Supports multiple mainstream languages: C/C++, Python, Java
- Can be tested online for easy debugging
2. The main purpose of brushing leetcode
- Be familiar with the algorithm problems of various Internet companies and prepare for finding a job.
- Review the programming languages I have learned before. LeetCode supports almost all mainstream programming languages, and everyone can do the questions in different languages.
- Familiar with common algorithms and data structures, LeetCode provides a communication platform. Some masters will post their own solutions to share, and some clever solutions are really amazing.
- Learn other people's programming thinking, speed up programming, and avoid common bugs.
In addition, LeetCode's question types are very simple and clear, and do not require complex understanding. They can usually be solved within 50 lines. If you write hundreds of lines of code, it will definitely mean that you are thinking too much or too complicated. Although they can be solved with very short code, it does not mean that LeetCode's question is very simple. In fact, LeetCode basically involves all conventional algorithm types.
The biggest advantage of brushing LeetCode is that it can exercise the thinking ability to solve problems. Believe me, how to think is itself a skill that requires constant learning and practice. In addition, a large number of high-quality questions can deepen our understanding of classics in computer scienceData structuredeep understanding of the problem can be quickly solved with appropriate data structures. We see many ACM masters who can come up with solutions immediately after getting the question, probably because they have a deep understanding of various data structures.
3. Commonly used data structures
- Stack: Simply put, it has the characteristics of back-in-first-out, and it is also wonderful to apply it in detail. You can take a look at the question 32. Longest Valid Parenteses.
- Linked List: Linked lists can be inserted and deleted quickly, but searching is time-consuming (it is much easier to combine with the graph when operating the linked list, and you should pay attention to empty nodes). Usually, related problems of linked lists can be cleverly solved with double pointers. 160. Intersection of Two Linked Lists can help us re-examine the operations of linked lists.
- Hash Table: Use the Hash function to map data to a fixed area, which is convenient for reading and modification in O(1). 37. Sudoku Solver Sudoku is a classic backtracking problem. If combined with HashTable, the running time will be greatly reduced.
- Tree: Trees are widely used in computer disciplines, and commonly used are binary search trees, red and black books, B+ trees, etc. The establishment, traversal and deletion of trees are relatively complicated, and recursion is usually used. 113. Path Sum II is a good appetizer.
- Heap: A special completely binary tree, "stricken level", you can use the time complexity of O(nlogn) to sort, and you can use the time complexity of O(nlogk) to find the largest (small) k of n numbers. For details, you can take a look at 347. Top K Frequent Elements.
4. Commonly used algorithm ideas
In addition to data structures, specific algorithms are also very important in a program, and the measurement of algorithm efficiency isTime complexityand space complexity. For a programming problem, choosing different data structures and algorithms will lead to different implementation methods, such as the "longest common substring". Therefore, it is not enough to just write down the implementation of problems. You also need to know how to design algorithms for problems, and then analyze the complexity of the algorithm to compare the direct advantages and disadvantages of different implementations. Therefore, in addition to practicing questions, you also need to remember the time complexity and spatial complexity of each algorithm implementation. The most commonly used is Big O notation. Generally speaking, people pay more attention to time complexity and often hope to find algorithms that are faster than O(n^2). In the case of relatively large data volume, the algorithm time complexity is preferably O(logn) or O(n). There are so many classic algorithm ideas in the computer discipline. LeetCode The above questions cover most of them. Let's take a look at them roughly below.
- Dividing and conquer: It is a bit similar to the idea of "big things turn into small things, small things turn into small things". This idea is used in classic merge sorting and quick sorting. You can take a look at Search a 2D Matrix II to understand this idea.
- Dynamic programming: It is somewhat similar to the inductive summary method in mathematics, find the state transfer equation, and then gradually solve it. 309. Best Time to Buy and Sell Stock with Cooldown is a good example of understanding dynamic programming.
- Greedy algorithm: Sometimes only focusing on local interests will lead to the best global benefits in the end. 122. Best Time to Buy and Sell Stock II See how to be "greedy".
- Search algorithm (depth priority, breadth priority, binary search): Finding solutions that meet conditions in a limited solution space. Depth and breadth are usually time-consuming. Binary search can reduce the scale of the problem by half each time, so it is more efficient.
- Backtracking: Keep trying and error, and at the same time, you should pay attention to turning back is the shore. If you can’t go through, change the path. In the end, you can find a solution to the problem or know that there is no solution to the problem. You can take a look at 131. Palindrome Partitioning.
Of course, there are some problems that may require some mathematical knowledge to solve, or someBit operationSkills to solve quickly. In short, we hope to find a solution with low time complexity. To achieve this, we may need to integrate multiple ideas in one problem-solving method
———————————————————————————————————————————
5. Choosing algorithm questions
After clicking on Algorithms, we can see a list of questions. Each question has a unique sequence number. The acceptance rate (Acceptance) below indicates the accuracy of the submission, and Difficulty indicates the difficulty.
LeetCode is divided into three levels according to its difficulty: Hard, Medium, and Easy.
- EasyLevels generally do not require too much thinking to think about algorithms, and can even be directly used, especially suitable for novices to become familiar with programming languages.
- MediumLevels will be somewhat difficult, and they usually involve classic algorithms, which require some thinking.
- HardLevel is the most difficult. Sometimes it is the difficulty of the algorithm itself, and sometimes it is especially necessary for you to consider various details.
1. Choice of the question
It is not advisable to practice questions blindly, so you must understand the purpose and reason of the question. There are actually 4 types:
- If you want to improve your thinking ability, you can find questions that match your current level of difficulty according to the AC rate (Accepted), and then challenge high-difficulty questions appropriately (the time complexity of the binary is O(logn), which at least saves time than the O(n) from easy to difficult)
- If you want to consolidate a topic, you should naturally follow the tag to write the question, but because the method used is known before solving it, it is not conducive to improving your thinking ability
- If you don’t understand anything, it is recommended to randomly practice questions. First, you can gain insights and second, there is a lot of room for improvement.
- If you want to improve your AC rate or increase your confidence, then it is recommended to brush water questions
There are still talents between people, but the difference is that experience can be accumulated slowly and there is another suggestion. If the question is too difficult to exceed your current ability, you should just look at the problem and solve it honestly after trying for a certain period of time.
2. How to write questions
Method 1: Sequence method
It is recommended that newcomers who have not tried the questions will come in order (AC). The first 150 questions cover many classic questions and knowledge points, such as the "3 sum" series, the dynamic rules category such as "regex matching", and the search questions such as "Sodoku Solver".
After basically being familiar with knowledge points (graphs, trees, stacks, linked lists, hash tables, memory searches, dynamic programming, pointer method, and collections), you can attack a class of tags with a strong attack. Although the tag system on the right side of Leetcode is not necessarily 100% complete, the rough classification is done well.
You can only do the "Hard" tag questions a month before the interview, because usually after two times, most questions below the difficulty of "Medium" are muscle memory. Practicing more "Hard" questions can make you broader your thinking, because the strange and erotic skills used in many questions are surprising, such as Leetcode's carefully designed continuous questions with "84. LargestRectangle in Histogram』、『85. Maximal Rectangle』。
Method 2: Label method
According to the different tags arranged for everyone by the website, they play a modular review and learning role. For example: For example, if you review the content of the linked list, choose the 23 questions in the Linked List. After brushing, you can summarize the commonly used methods, data structures and construction methods. Please don’t do the questions just to make up for some of the knowledge.
Method 3: Random method
Choose the difficulty and order of the questions as you like, which one pleases you. This method is only suitable for amateur programming, students and great figures who are not engaged in this industry.
Method 4: The method of killing
Leetcode has a company question bank, in one sentence: which one is used and which one is used to buy
6. Question-making strategy
TIP 1：
As we all know, in ancient times, it was known that he had finished all the questions of leetcode, but because there were only 150 questions at that time. As of January 2018, leetcode has had 700 questions, and some of them are quite difficult. If you have to finish it all, you can't find any other purpose except wasting your own time.
Therefore, for most people, there is no time and no need to do all the questions (you can do it as you have enough time). You can consider questions with the first 250 digits, because those are all classics and required questions.
TIP 2：
Make good use of favorites, and develop the habit of "adding to favorites if you can't solve the second exercise of one question", and you need to clear your favorites regularly: each question is not prompted to pass twice before you can move out of your favorites. It is easy to just want the answer. The question comment section has a variety of answers, and it is often shown a line of python code to solve it. So many people like it. The question is, are you learning the weird skills and tricks of programming languages or learning algorithm thinking? Do your happiness come from copying a line of code from someone else and passing the test and completing the question +1, or do you come from writing the solution through logical reasoning and algorithm frameworks without looking at the answer? Classic questions cannot be finished just by just reading them once. They have to read them many times, because when you are brushing a special topic, you will definitely forget some of the previous knowledge. For example, if you are greedy, you may be a little confused when you go back. So you must read more to deepen your memory, and then start reading the summary chapters of each topic for a quick review before the interview.
TIP 3：
You can do it in the order of frequency of interview questions below, starting from the batch with the highest frequency. And please try not to use the IDE and write code directly on the platform.
You can purchase members before the interview, practice according to the company's label, or practice in combination with the whiteboard. If time is tight before the interview, the priority of practice is: the questions of the company that will be interviewed, the old questions in the favorites, and the remaining new questions.
Please try not to open the question type tab during the sprint stage to give yourself room to think. If you really can’t achieve your ideal goal after you have tried it more than three times, then it must be a problem with your learning method. Please summarize it more.
TIP 4：
Don’t submit the code first when writing it. Manually check the code, such as whether there are any semicolons written, whether there are any return, etc. After manual inspection, use the "Custom Testcase" function to customize the test cases, pay attention to checking the boundaries, and then "Run Code". This step can find a lot of problems. Wait until RunCode passes, then submit.