Leetcode树刷题顺序

已于 2023-09-09 16:32:22 修改
阅读量625 收藏 1
点赞数
分类专栏： Leetcode 文章标签： leetcode 算法 职场和发展
于 2021-01-01 13:25:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43521670/article/details/112059846
版权

文章目录

100. 相同的树

难度简单312
给定两个二叉树，编写一个函数来检验它们是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
示例 1:

输入: 1         1
          / \       / \
         2   3     2   3
        [1,2,3],   [1,2,3]
输出: true

示例 2:

输入: 1       1
          /           \
         2             2
        [1,2],     [1,null,2]
输出: false

示例 3:

输入: 1         1
          / \       / \
         2   1     1   2
        [1,2,1],   [1,1,2]
输出: false

思路：基于递归思想，此题首先要知道

1.左右子树都为空的时候返回true;

2.左子树或者右子树为空的时候此时返回false;

3.左子树的值不等于右子树的值返回false;

4.然后递归判断其两个树的左右子树递归下去；

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */


bool isSameTree(struct TreeNode* p, struct TreeNode* q){
    if(p == NULL && q == NULL) return true;
    if(p == NULL || q == NULL ) return false;
    if( p->val - q->val) return false;
    return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);//继续判断两个树
}
101. 对称二叉树

难度简单631

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

    1
   / \
  2   2
 / \ / \
3  4 4  3

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

    1
   / \
  2   2
   \   \
   3    3

说明:

如果你可以运用递归和迭代两种方法解决这个问题，会很加分。

image.png

思路：当判断是否是对称二叉树时，我们应该把其左右子树进行比较是否对称；
1.把左右树传进去
2.分别递归两个树，如果全为空返回true,一方为空返回false，值相同时返回true;
3.然后递归判断一个树左子树是否与另一棵树的右子树相同并且一个树的右子树是否与另一棵树的左子树相同；

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

bool ismirror(struct TreeNode *p, struct TreeNode *q) {
    if(p == NULL &&q == NULL) return true;
    if(p == NULL || q == NULL) return false;
    return  (p->val == q->val) &&ismirror(p->left, q->right) && ismirror(p->right, q->left);
}
bool isSymmetric(struct TreeNode* root){
    if(root == NULL) return true;
    return ismirror(root, root);
}
102. 二叉树的层次遍历

难度中等391

给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。

例如:
给定二叉树: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果：

[
  [3],
  [9,20],
  [15,7]
]

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */


/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */

int getDepth(struct TreeNode *root) {//获取子树的最大深度
    if(root == NULL) return 0;
    int l = getDepth(root->left), r = getDepth(root->right);
    return (l > r ? l : r ) +  1;
}

void getCnt(struct TreeNode *root, int k, int *cnt) {//获取每一层有多少个结点
    if(root == NULL) return ;
    cnt[k] += 1;
    getCnt(root->left, k + 1, cnt);
    getCnt(root->right, k + 1, cnt);
    return;
}

void getResult(struct TreeNode *root, int k, int *cnt, int **ret) {//将每一层的结点
    if(root == NULL) return;
    ret[k][cnt[k]++] = root->val;//将每一层的节点对应不同的维度压进去
    getResult(root->left, k + 1, cnt, ret);//继续遍历左子树
    getResult(root->right, k + 1, cnt, ret);//继续遍历右子树
    return;
}


int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
    int depth = getDepth(root);//先获取树的最大深度
    int **ret = (int **)malloc(sizeof(int *) * depth);//定义一个二维数组，大小为深度
    int *cnt = (int *) calloc(depth, sizeof(int));//定义一个一维数组calloc进行清空大小为深度
    getCnt(root, 0, cnt);//将ｃｎｔ传入获取对应的每一层有多少个结点
    //cnt[0] = 1, cnt[1] = 2, cnt[2] = 2;
    for(int i = 0; i < depth; i++) {//二维数组每一层存cnt[i]个数，一共有depth层
        ret[i] = (int *)malloc(sizeof(int ) * cnt[i]);
        cnt[i] = 0;//使用过的cnt清空，以便下面使用对应着哪一层
    }
    getResult(root, 0, cnt, ret);//将二维数组进行对应树赋值
    *returnSize = depth;
    *returnColumnSizes = cnt;
    return ret;
}
104. 二叉树的最大深度

难度简单467

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。

**思路：**左子树有一个深度，右子树哟偶一个深度，左右子树的最大深度加上本层就是总的深度，递归处理

int maxDepth(struct TreeNode* root){
    if(root == NULL) return 0;
    int l = maxDepth(root->left), r= maxDepth(root->right);//左子树的深度和右子树的深度
    return (l > r ? l : r) + 1;//左右子树的最大的一个深度加上本层１就是此时结点树的最大深度
}
107. 二叉树的层次遍历 II

难度简单191收藏分享切换为英文关注反馈

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

例如：
给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回其自底向上的层次遍历为：

[
  [15,7],
  [9,20],
  [3]
]

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */


/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */

int getDepth(struct TreeNode *root) {//获取树的最大深度
    if(root == NULL) return 0;
    int l = getDepth(root->left);
    int r = getDepth(root->right);
    return (l > r ? l : r) + 1;
}

void getCnt(struct TreeNode *root, int k , int *cnt) {//获取每一层有多少个结点
    if(root == NULL) return;
    cnt[k] += 1;
    getCnt(root->left, k - 1, cnt);
    getCnt(root->right, k - 1, cnt);
    return;
}

void getResult(struct TreeNode *root, int k, int *cnt, int **ret) {//从下往上进行存储每一层的数据
    if(root == NULL) return ;
    ret[k][cnt[k]++] = root->val;
    getResult(root->left, k - 1, cnt, ret);
    getResult(root->right, k - 1, cnt, ret);
    return ;
}
int** levelOrderBottom(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
    int n = getDepth(root);
    int **ret = (int **) malloc(sizeof(int *) * n);
    int *cnt = (int *)calloc(n, sizeof(int));
    getCnt(root, n - 1, cnt);//树是从下往上
    for(int i = 0; i < n; i++) {
        ret[i] = (int *)malloc(sizeof(int) * cnt[i]);
        cnt[i] = 0;
    }
    getResult(root, n - 1, cnt, ret);
    *returnSize = n;
    *returnColumnSizes = cnt;
    return ret;
}
110. 平衡二叉树

难度简单244

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

    3
   / \
  9  20
    /  \
   15   7

返回 true 。

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

       1
      / \
     2   2
    / \
   3   3
  / \
 4   4

返回 false 。

**思路：**获取一个左右子树的深度，然后进行比较，然后递归左右子树，//不平衡的情况有3种：左树不平衡、右树不平衡、左树和右树差的绝对值大于1 ，//不满足上面3种情况，说明平衡了，树的深度为左右俩子树最大深度+1

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

/*
int Depth(struct TreeNode *root) {//获取最大的深度
    if(root == NULL) return 0;
    int l = Depth(root->left), r = Depth(root->right);
    return (l > r ? l : r) + 1;
}

bool isBalanced(struct TreeNode* root){
    if(root == NULL) return true;
    int l = Depth(root->left);//获取左右孩子的深度；
    int r = Depth(root->right);
    if(abs(l - r) > 1) return false;//进行比较差值
    return isBalanced(root->left) && isBalanced(root->right);//继续递归比较左右孩子的深度；
}
*/
int Balanced(struct TreeNode *root) {
    if(root == NULL) return 0;
    //不平衡的情况有3种：左树不平衡、右树不平衡、左树和右树差的绝对值大于1
    int left = Balanced(root->left);
    if(left == -1) return -1;
    int right = Balanced(root->right);
    if(right == -1) return -1;
    if(abs(left - right) > 1) return -1;
    //不满足上面3种情况，说明平衡了，树的深度为左右俩子树最大深度+1
    return (left > right ? left : right) + 1;

}
bool isBalanced(struct TreeNode* root){
    return Balanced(root) != -1;
}


/*
int Depth(struct TreeNode *root) {
    if(root == NULL) return 0;
    int l = Depth(root->left), r = Depth(root->right);
    if(l == -2 || r == -2 || abs(l - r) > 1) return -2;
    return (l > r ? l : r) + 1;
}

bool isBalanced(struct TreeNode* root){
    return Depth(root) >= 0;
}
*/
111. 二叉树的最小深度

难度简单216

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明: 叶子节点是指没有子节点的节点。

示例:

给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回它的最小深度 2.

**思路：**如果此时左孩子为空，右孩子不为空，返回右边孩子最小深度加上本层（＋１），如果左孩子不为空，右孩子为空，返回左孩子加上本层（＋１），其他的话（其左右孩子全为空，全为不空时），那就返回走右子树最小的加上本层；

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/*
int minDepth(struct TreeNode* root){
    if(root == NULL) return 0;
    if(root->left == NULL && root->right == NULL) return 1;
    if(root->left == NULL ||root->right == NULL) {
        return minDepth(root->left ? root->left : root->right)  + 1;
    }
    return fmin(minDepth(root->left), minDepth(root->right)) + 1;
}
*/
int minDepth(struct TreeNode* root){
    if(root == NULL) return 0;
    if(root->left == NULL && root->right != NULL) {//左孩子为空，右孩子不为空
        return 1 + minDepth(root->right);//右边孩子最小深度＋１
    }
    if(root->right == NULL && root->left != NULL) {//左孩子不为空，右孩子为空
        return 1 + minDepth(root->left);//返回左边孩子的最小深度＋１
    }
    return fmin(minDepth(root->left), minDepth(root->right)) + 1;//返回左右孩子最小的那个＋１
}
112. 路径总和

难度简单245

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

说明: 叶子节点是指没有子节点的节点。

示例:
给定如下二叉树，以及目标和 sum = 22，

              5
             / \
           4    8
          /     /  \
        11  13   4
       /  \             \
     7    2             1

返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。

**思路:**DFS，记录每一层的值，递归出口：左右孩子为空，此时sum 减去本层为０，就可以判定是否存在路径，因为可能有多条路径，所以要用“||”进行对左孩子右孩子进行递归然后减去本层的值，如果搜到则返回１,直至到递归出口

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
bool hasPathSum(struct TreeNode* root, int sum){
    if(root == NULL) return false;
    if(root->left == NULL && root->right == NULL) {
        return sum - root->val == 0;
    }
    return (hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum -root->val));
}
226. 翻转二叉树

难度简单373

翻转一棵二叉树。

示例：

输入：

     4
   /   \
  2     7
 / \   / \
1   3 6   9

输出：

     4
   /   \
  7     2
 / \   / \
9   6 3   1

思路：如何翻转一个二叉树，只有左右对应的孩子进行交换才能进行反转，所以得设置一个中间变量进行反转二叉树，然后进行递归左右孩子

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
struct TreeNode* invertTree(struct TreeNode* root){
    if(root == NULL)return NULL;
        struct TreeNode *s;
        s = root->left;
        root->left = root ->right;
        root->right = s;
        invertTree(root->left);
        invertTree(root->right);
    return root;
}
235. 二叉搜索树的最近公共祖先

难度简单240

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]

img

示例 1:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6 
解释: 节点 2 和节点 8 的最近公共祖先是 6。

示例 2:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。

说明:

  • 所有节点的值都是唯一的。
  • p、q 为不同节点且均存在于给定的二叉搜索树中。

**思路：**如何判断其最近的公共祖先，可以分为三种情况
1.如果此时值小于p->val,q->val，那么肯定就得往右找合适的祖先
2.如果此时值大于p->val,q->val, 那么肯定就得往左找合适的祖先
3.如果找到的值在他们两个之间，那么肯定就是所要找的公共祖先

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) {
    if(root == NULL) return root;
    if(root ->val  < p->val && root ->val < q->val) {
        return lowestCommonAncestor(root->right, p, q);
    }else if(root ->val  > p->val && root ->val > q->val) {
        return lowestCommonAncestor(root->left, p, q);
    } else {
        return root;
    }
}
257. 二叉树的所有路径

难度简单213

给定一个二叉树，返回所有从根节点到叶子节点的路径。

说明: 叶子节点是指没有子节点的节点。

示例:

输入:

   1
 /   \
2     3
 \
  5

输出: ["1->2->5", "1->3"]

解释: 所有根节点到叶子节点的路径为: 1->2->5, 1->3

**思路：**二叉树有多条路径，我们可以把他的多条路径存在一个二维数组里，获取二叉树有路径个数，然后将他们分别存在相互对应的路径里，

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/*
void dfs(struct TreeNode *root, char **bin_tree_paths, int *path, int *return Size, int depth) {
    int i = 0;
    path[depth++] = root->val;
    if(root->left == NULL && root->right == NULL) {
        bin_tree_path[*returnSize] = (char *)malloc(sizeof(char) * 100);
        bin_tree_path[*returnSize][0] = 0;
        for(i = 0; i < depth - 1; i ++) {
            sprintf(bin_tree_paths[*returnSize], "%s%d", bin_tree_paths[*returnSize], path[i]);
        }
    }
}*/

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
/*
char ** binaryTreePaths(struct TreeNode* root, int* returnSize){
    int path[100] = {0}, depth = 0;
    char ** bin_tree_path = (char **)malloc(sizeof(char *) * 100);
    if(root == NULL) return root;
    *returnSize = 0;
    dfs(root, bin_tree_path, path, returnSize, depth);
    return bin_tree_paths;
}*/
int getPathCnt(struct TreeNode *root) {//获取路径个数
    if(root == NULL) return 0;
    if(root ->left == NULL && root->right == NULL) return 1;
    return getPathCnt(root->left) + getPathCnt(root->right);
}

int getResult(struct TreeNode *root, int len, int k, char **ret, char *buff) {//len是每条路径元素个数,k表示第几条路
    if(root == NULL) return 0;
    len += sprintf(buff + len, "%d", root->val);//当加入数时表示此时路径中元素个数len+"",buff存储此时路径
    buff[len] = 0;//将ｂｕｆｆ置为零
    if(root->left == NULL && root->right == NULL) {
        ret[k] = strdup(buff);//如果走到叶子节点时，那么将ｂｕｆｆ存储的路径给二维数组的第ｋ层
        return 1;
    }
    len += sprintf(buff + len, "->");//将箭头加入buff;
    int cnt  = getResult(root->left, len, k, ret, buff);//往左搜
    cnt += getResult(root->right, len,k+cnt,ret,buff );//往右子树搜
    return cnt;
}

char ** binaryTreePaths(struct TreeNode* root, int* returnSize){
    int pathCnt = getPathCnt(root);//获取路径的个数
    char **ret = (char **)malloc(sizeof(char *) * pathCnt);//开辟一个字符型的二维数组；
    int max_len = 1024;
    char *buff = (char * )malloc(sizeof(char) * max_len);//存储每个路径里的所有元素
    getResult(root, 0, 0, ret, buff);
    *returnSize = pathCnt;
    return ret;
}
一.Leetcode刷题顺序
11-14 466
1.按照数据结构 数组和链表（二分查找，排序（初级排序（选择，插入，希尔），高级排序（归并，快速，优先队列）），双指针，滑动窗口）， 栈和队列（单调栈，单调队列，优先队列），树（二叉树, 二叉查找树， 平衡查找树，堆），图（无向图（DFS，BFS ），有向图，最小生成树（Prim,Kruskal）,最短路径（Dijkstra）），Hash 2.按照算法思想 递归，回溯，分治，贪心，动态规划（背包） ......
Leetcode刷题顺序（自用更新中）
Devil_B的博客
12-09 1246
Leetcode刷题顺序与总结（更新中） 文章目录Leetcode刷题顺序与总结（更新中）前言一、数组1.二分法二、链表总结 前言 刷题顺序：先从同一类型里题目开始刷起，同一类型里再从简单到中等到困难刷起，题型顺序建议：数组-> 链表-> 哈希表->字符串->栈与队列->树->回溯->贪心->动态规划->图论。整理一些自己在刷题时的想法，参考链接：https://github.com/youngyangyang04/leetcode-master
leetcode 精选刷题顺序
qq_43460108的博客
07-21 3241
题目分类及刷题顺序推荐 一. 数组 题目分类 题目编号 数组的遍历 485、495、414、628 统计数组中的元素 645、697、448、442、41、274 数组的改变、移动 453、665、283 二维数组及滚动数组 118、119、661、598、419 数组的旋转 189、396 特定顺序遍历二维数组 54、59、498 二维数组变换 566、48、73、289 前缀和数组 303、304、238 题解 数组篇 二. 字符串 题目分类 题目编号 字符 520 回文串的定义 125 公共前缀 14
leetcode的刷题顺序
最新发布
AlgorithmHero的博客
08-23 799
LeetCode还有一些特殊类型的题目，如数据库、多线程、设计问题等，根据自己的兴趣和需求，选择性地刷一些。从数据结构入手，先刷一些基本的数据结构题目，如数组、链表、栈、队列等，帮助巩固基本的数据结构知识。接着刷一些基础算法题目，如递归、二分查找、排序等，这些算法在解决其他题目时会经常用到。在掌握了基本的数据结构和算法后，可以尝试一些高级的算法，如位运算、并查集等。字符串问题也很常见，刷一些字符串处理的题目，如字符串匹配、反转、去重等。刷图算法相关的题目，如拓扑排序、最小生成树等，加深对图算法的了解。
leecode刷题顺序
janet1100的博客
11-23 614
开篇的话：LeetCode题目太多，且其中的基本知识点其实是变化不大的，因此全部刷完肯定不是最好最有效的方式。短时间刷不完也记不住。所以要刷经典题，要刷一题掌握一个类型，遇到新题需要和刷过的题总结归类到一起，才能以不变应万变，真正提高。 因此，照着这个分类来一波吧，保证有奇效，我自己受益良多！ 这门课程是一个算法总结提高的课程，它把算法面试中可能遇到的题分成了各种模式，每类题各个击破 比如有最经典的sliding window模式，Two pointers模式，快慢指针模式，合并intervals模式
LeetCode 按照怎样的顺序来刷题比较好？
yygr的博客
07-01 450
https://blog.csdn.net/kexuanxiu1163/article/details/106638251?spm=1001.2101.3001.6661.1&utm_medium=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-1-106638251-blog-125099023.pc_relevant_multi_platform_whitelistv1&depth_1-utm_source
LeetCode刷题顺序
Hello World
11-12 179
GitHub地址
leetcode小岛出水口-leetcode:leetcode刷题顺序，JavaScript实现
06-30
leetcode小岛出水口 Leetcode 基本按照bobo老师的算法课程分类，bobo的。 他是用C++做的，这里用JavaScript实现。 Problems Difficulty Solution Array 数组 001 Easy 002 Easy 003 Easy 004 Medium 005 Medium 006 ...
JAVA小白leetcode刷题顺序--offer:-提供
07-06
JAVA小白leetcode刷题顺序 本人也是java小白一个，刷题剑指offer也是开始第三遍，准备记录一下每道题的一些通用解法，可能不是最优的，但一定是最容易理解和接受的~ 小白选取的《剑指offer》是LeetCode上面的剑指...
LeetCode 刷题顺序
weixin_52552177的博客
10-17 456
数字的位操作 7、9、479、564、231、342、326、504、263、190、191、476、461、477、693、393、172、458、258、319、405、171、168、670、233、357、400。数组与贪心算法 605、121、122、561、455、575、135、409、621、179、56、57、228、452、435、646、406、48、169、215、75、324、517、649、678、420。
leetcode刷题顺序
IBelieve2016的博客
02-27 1872
https://zhuanlan.zhihu.com/p/104983442 作者：穷码农 链接：https://www.zhihu.com/question/36738189/answer/908664455 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 原文章在这里： https://hackernoon.com/14-patterns-to-ac...
树的遍历:144. 二叉树的前序遍历
aishenla的博客
12-08 327
给你二叉树的根节点root，返回它节点值的前序遍历。 方法一：递归 思路与算法 首先我们需要了解什么是二叉树的前序遍历：按照访问根节点——左子树——右子树的方式遍历这棵树，而在访问左子树或者右子树的时候，我们按照同样的方式遍历，直到遍历完整棵树。因此整个遍历过程天然具有递归的性质，我们可以直接用递归函数来模拟这一过程。 定义 preorder(root) 表示当前遍历到 root 节点的答案。按照定义，我们只要首先将 root 节点的值加入答案，然后递归调用 preorder(root.lef...
LeetCode 刷题顺序，按标签分类，科学刷题！
热门推荐
yygr的博客
06-02 1万+
https://zhuanlan.zhihu.com/p/501483324很多初学算法的同学，对着LeetCode从头开刷，结果磕磕碰碰没几个AC。挫败感上来就刷不动了，其实掌握科学刷题顺序能让你事半功倍！今天就来总结下正确的刷题顺序，大家跟着刷就行！在刷题之前，如果时间充足，一定要先了解一道算法题考察的知识点，同一个知识点可以触类旁通，强化联系。下面把Leetcode上的题目按结构化标签分类，供你参考。一定要按照按照题目类别结构化地刷题 ！！！这样刷题的速度不仅更快，而且可以在刷完一类题之后进行总结。对
LeetCode按照怎样的顺序来刷题更有效？
IT1124的博客
01-19 2355
如果你时间比较紧迫，为了找工作而刷题，我建议你先刷热门推荐，一共两百多道题。 在 https://leetcode-cn.com/problemset/all/ 页面的右侧。先刷热题 HOT 100，再刷精选 TOP 面试题，之后刷其他的题。 如果你时间比较充裕，那我建议你： 按从低到高的难度分组刷 按 tag 分类刷 定期复习，重做之前刷过的题 掌握 LeetCode 刷题方法再开始刷题，属于磨刀不误砍柴工。掌握正确方法是非常重要的。 如果你在刷题的时候发现怎么也写不出来，别担心，这
leetcode-leetcode:leetcode顺序刷题，详细通俗题解，withJAVA
06-29
为什么刷题： 知乎开设了专栏，同步更新：，关注后可以及时收到更新，网站有时候可能出问题打不开，建议关注一下知乎专栏备用 准备刷一道，总结一道。 可以加好友一起交流。 微信： 17771420231 公众号： windliang...
Leetcode刷题 树专题
weixin_43095021的博客
05-06 170
二叉树的定义 struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; 98. 验证二叉搜索树 //树的左边必然比当前值小，树的右边必然比当前值大。 class So...
LeetCode刷题顺序（新手入门）
falldeep的算法世界
11-06 4328
移动零给定一个数组nums，编写一个函数将所有0移动到数组的末尾，同时保持非零元素的相对顺序。请注意，必须在不复制数组的情况下原地对数组进行操作。难点就是不复制原数组要原地修改，解法为设置一个res，记录前面的0的个数，每次插入时只要插入到nums[i - res]中即可移除元素给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
Leetcode刷题顺序
艺博❀
07-14 752
这个重点题目是我个人把Leetcode前400题进行精简，精简方法如下： 删除不常考，面试低频出现题目 删除重复代码题目（例：链表反转206题，代码在234题出现过） 删除过于简单题目（例：100题：Same Tree） 删除题意不同，代码基本相同题目（例：136 & 389，保留一个） 所有题目我尽量保证客观公正，只是按大概率删除不常考题目，很多题目面经出现过，但出现次数属于个位数或者只有一两家出现。 只是参看:如在面试中出现题目概不负责
数据结构 leetcode 刷题顺序
chumingqian的博客
05-02 838
1. 算法性能分析 主要 分 时间复杂度 和空间复杂度 两大部分； 自己查询； 2. 数组 3. 链表 4. 哈希表 5. 字符串 6. 栈与 队列 7. 二叉树 专题 8. 回朔算法 9. 贪心算法 10. 动态规划
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值
>