本文共 6505 字，大约阅读时间需要 21 分钟。

摘自：

 

目录：

 

算法面试思维导图

 

算法文章精选

• 精选链表相关的面试题
• 精选字符串相关的面试题
• 精选栈与队列相关的面试题
• 精选二叉树相关的面试题
• 精选递归与回溯面试题

（持续更新中....）

 

LeetCode 刷题攻略

刷题顺序：建议先从同一类型里题目开始刷起，同一类型里再从简单到中等到困难刷起，题型顺序建议：数组-> 链表-> 哈希表->字符串->栈与队列->树。

这里我总结了各个类型的经典题目，初学者可以按照如下顺序来刷题，算法老手可以按照这个list查缺补漏！

• 数组经典题目

• 链表经典题目

• 哈希表经典题目

  • 0220.存在重复元素III

• 字符串经典题目

  • 延伸左旋转字符串（剑指offer上的题目）

• 栈与队列经典题目

• 二叉树经典题目

（持续补充ing）

 

算法模板

 

二分查找法

class Solution {public:    int searchInsert(vector
   
    & nums, int target) {        int n = nums.size();        int left = 0;        int right = n; // 我们定义target在左闭右开的区间里，[left, right)          while (left < right) { // 因为left == right的时候，在[left, right)是无效的空间            int middle = left + ((right - left) >> 1);            if (nums[middle] > target) {                right = middle; // target 在左区间，因为是左闭右开的区间，nums[middle]一定不是我们的目标值，所以right = middle，在[left, middle)中继续寻找目标值            } else if (nums[middle] < target) {                left = middle + 1; // target 在右区间，在 [middle+1, right)中            } else { // nums[middle] == target                return middle; // 数组中找到目标值的情况，直接返回下标            }        }        return right;    }};
   

 

KMP

void kmp(int* next, const string& s){    next[0] = -1;    int j = -1;    for(int i = 1; i < s.size(); i++){        while (j >= 0 && s[i] != s[j + 1]) {            j = next[j];        }        if (s[i] == s[j + 1]) {            j++;        }        next[i] = j;    }}

 

二叉树

二叉树的定义：

struct TreeNode {    int val;    TreeNode *left;    TreeNode *right;    TreeNode(int x) : val(x), left(NULL), right(NULL) {}};

 

深度优先遍历（递归）

前序遍历（中左右）

void traversal(TreeNode* cur, vector
   
    & vec) {    if (cur == NULL) return;    vec.push_back(cur->val);    // 中 ，同时也是处理节点逻辑的地方    traversal(cur->left, vec);  // 左    traversal(cur->right, vec); // 右}
   

中序遍历（左中右）

void traversal(TreeNode* cur, vector
   
    & vec) {    if (cur == NULL) return;    traversal(cur->left, vec);  // 左    vec.push_back(cur->val);    // 中 ，同时也是处理节点逻辑的地方    traversal(cur->right, vec); // 右}
   

中序遍历（中左右）

void traversal(TreeNode* cur, vector
   
    & vec) {    if (cur == NULL) return;    vec.push_back(cur->val);    // 中 ，同时也是处理节点逻辑的地方    traversal(cur->left, vec);  // 左    traversal(cur->right, vec); // 右}
   

 

深度优先遍历（迭代法）

相关题解：

前序遍历（中左右）

vector
   
     preorderTraversal(TreeNode* root) {    vector
    
      result;    stack
     
       st;    if (root != NULL) st.push(root);    while (!st.empty()) {        TreeNode* node = st.top();        if (node != NULL) {            st.pop();            if (node->right) st.push(node->right);  // 右            if (node->left) st.push(node->left);    // 左            st.push(node);                          // 中            st.push(NULL);                                  } else {            st.pop();            node = st.top();            st.pop();            result.push_back(node->val);            // 节点处理逻辑        }    }    return result;}
     
    
   

中序遍历（左中右）

vector
   
     inorderTraversal(TreeNode* root) {    vector
    
      result; // 存放中序遍历的元素    stack
     
       st;    if (root != NULL) st.push(root);    while (!st.empty()) {        TreeNode* node = st.top();        if (node != NULL) {            st.pop();             if (node->right) st.push(node->right);  // 右            st.push(node);                          // 中            st.push(NULL);             if (node->left) st.push(node->left);    // 左        } else {            st.pop();             node = st.top();             st.pop();            result.push_back(node->val);            // 节点处理逻辑        }    }    return result;}
     
    
   

后序遍历（左右中）

vector
   
     postorderTraversal(TreeNode* root) {    vector
    
      result;    stack
     
       st;    if (root != NULL) st.push(root);    while (!st.empty()) {        TreeNode* node = st.top();        if (node != NULL) {            st.pop();            st.push(node);                          // 中            st.push(NULL);            if (node->right) st.push(node->right);  // 右            if (node->left) st.push(node->left);    // 左        } else {            st.pop();            node = st.top();            st.pop();            result.push_back(node->val);            // 节点处理逻辑        }    }    return result;}
     
    
   

 

广度优先遍历（队列）

相关题解：

vector
   
    
     > levelOrder(TreeNode* root) {    queue
     
       que;    if (root != NULL) que.push(root);    vector
      
       
        > result;    while (!que.empty()) {        int size = que.size();        vector
        
          vec; for (int i = 0; i < size; i++) {// 这里一定要使用固定大小size，不要使用que.size() TreeNode* node = que.front(); que.pop(); vec.push_back(node->val); // 节点处理的逻辑 if (node->left) que.push(node->left); if (node->right) que.push(node->right); } result.push_back(vec); } return result;}
        
       
      
     
    
   

可以直接解决如下题目：

• 0111.二叉树的最小深度（迭代法）

 

二叉树深度

int getDepth(TreeNode* node) {    if (node == NULL) return 0;    return 1 + max(getDepth(node->left), getDepth(node->right));}

 

二叉树节点数量

int countNodes(TreeNode* root) {    if (root == NULL) return 0;    return 1 + countNodes(root->left) + countNodes(root->right);}

（持续补充ing）

 

LeetCode 最强题解:

题目	类型	难度	解题方法
	数组	简单	暴力 哈希
	数组	中等	双指针 哈希
	回溯	中等	回溯
	数组	中等	双指针
	栈	简单	栈
	链表	简单	模拟
	数组	简单	暴力 快慢指针/快慢指针
	数组	简单	暴力 双指针/快慢指针/双指针
	字符串	简单	KMP
	数组	简单	暴力 二分
	数组/回溯	中等	回溯
	数组/回溯	中等	回溯
	回溯	中等	回溯
	回溯	中等	回溯
	回溯	中等	回溯
	数组	简单	暴力 贪心 动态规划 分治
	数组	中等	模拟
	回溯	中等	回溯
	回溯/数组	中等	回溯
	链表	简单	模拟
	回溯/数组	中等	回溯
	回溯	中等	回溯
	树	中等	递归 迭代/栈
	树	中等	递归
	树	简单	递归
	树	简单	递归 迭代/队列/栈
	树	中等	广度优先搜索/队列
	树	简单	递归 迭代/队列/BFS
	树	简单	递归
	树	简单	递归 队列/BFS
	回溯	中等	回溯
	链表	中等	快慢指针/双指针
	树	中等	递归 迭代/栈
	树	困难	递归 迭代/栈
	字符串	中等	模拟/双指针
	栈	简单	栈
	二叉树	中等	广度优先遍历/队列
	哈希表	简单	哈希
	链表	简单	模拟 虚拟头结点
	哈希表	简单	哈希
	链表	简单	双指针法 递归
	数组	中等	暴力 滑动窗口
	数组/回溯	中等	回溯
	哈希表	简单	哈希
	树	简单	递归
	队列	简单	队列
	二叉树	简单	递归 迭代
	栈	简单	栈
	链表	简单	原链表移除 添加虚拟节点 递归
	滑动窗口/队列	困难	单调队列
	哈希表	简单	哈希
	字符串	简单	双指针
	哈希/堆/优先级队列	中等	哈希/优先级队列
	哈希表	简单	哈希
	哈希表	简单	哈希
	数组	简单	暴力 字典计数 哈希
	树	中等	递归
	字符串	简单	模拟
	哈希表	中等	哈希
	字符创	简单	KMP
	字符串	简单	模拟
	哈希表	简单	哈希
	树	简单	递归 迭代
	树	中等	递归
	树	简单	递归 迭代
	树	简单	递归 迭代
	哈希表	简单	模拟
	链表	中等	模拟
	栈	简单	栈
	字符串	简单	双指针
	链表	简单	模拟

持续更新中....

 

关于作者

大家好，我是程序员Carl，ACM 校赛、黑龙江省赛、东北四省赛金牌，和亚洲区域赛铜牌获得者，哈工大计算机硕士毕业，先后在腾讯和百度从事后端技术研发，CSDN博客专家。对算法和C++后端技术有一定的见解，利用工作之余重新刷leetcode。

加我的微信，备注：组队刷题， 拉你进刷题群，每天一道经典题目分析，而且题目不是孤立的，每一道题目之间都是有关系的，都是由浅入深一脉相承的，所以学习效果最好是每篇连续着看，也许之前你会某些知识点，但是一直没有把知识点串起来，这里每天一篇文章就会帮你把知识点串起来。我也花了不少精力来整理我的题解，而且我不会在群里发任何广告，纯自己学习和分享。 欢迎你的加入！

 

我的公众号

更多精彩文章持续更新，微信搜索：「代码随想录」第一时间围观，关注后回复： 「简历模板」「java」「C++」「python」「算法与数据结构」 等关键字就可以获得我多年整理出来的学习资料。

每天8：35准时为你推送一篇经典面试题目，帮你梳理算法知识体系，轻松学习算法！

About

LeetCode 刷题攻略：配思维导图，各个类型的经典题目刷题顺序、经典算法模板，以及详细图解和视频题解。这里精选的题目都不是孤立的，而是由浅入深一脉相承的，相信只要按照刷题攻略上的顺序来学习，一定会有所收获！

Resources

 

No releases published

No packages published

转载地址：http://hdlni.baihongyu.com/