Day 15 层序遍历 226.翻转二叉树 101.对称二叉树

已于 2024-04-06 23:05:15 修改
阅读量1.6k 收藏 51
点赞数 33
分类专栏： 代码随想录训练营 文章标签： 算法
于 2024-04-03 23:38:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46025584/article/details/137360540
版权

层序遍历

​ 昨天讲的无论是递归还是迭代，都是深度优先遍历；

​ 层序遍历则是广度优先遍历，一层一层的从左至右依次遍历，如图：

​ 正如需要用栈这具有先进后出的数据结构来辅助进行深度优先遍历，同样需要另一种辅助数据结构来实现广度优先遍历；由于遍历的顺序是一层一层的从左至右，符合此条件的则是队列的先进先出；用队列实现方式则如下图所示：

​ 下面这题可以说是母题一般的存在

力扣102题，层序遍历

​ 具体代码实现如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;//定义队列来存放二叉树节点
        vector<vector<int>> res;//定义二维数组来存放每一层的节点
        if(root != NULL)	que.push(root);
        else return res;
        while(!(que.empty())){//队列非空时，持续进行遍历操作，当队列为空的时候说明所有的节点元素均已弹出
        	int size = que.size();
            vector<int> temp;
        	while(size--){
            	TreeNode* node = que.front();
            	que.pop();
            	temp.push_back(node->val);
            	if(node->left)	que.push(node->left);
            	if(node->right)	que.push(node->right);
        	}
            res.push_back(temp);
        }
        return res;
    }
};

力扣107题 二叉树的层序遍历Ⅱ

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

107.二叉树的层次遍历II

代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> res;
        if(root != NULL)    que.push(root);
        else return res;
        while(!(que.empty())){
            int size = que.size();
            vector<int> temp;
            while(size--){
                TreeNode* node = que.front();
            	que.pop();
            	temp.push_back(node->val);
            	if(node->left)	que.push(node->left);
                if(node->right)	que.push(node->right);
            }
            res.push_back(temp);
        }
        reverse(res.begin(),res.end());//只需要添加reverse函数即可
        return res;
    }
};

力扣199题 二叉树的右视图

​ 给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

199.二叉树的右视图

​ 代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> res;
        if(root != NULL)	que.push(root);
        else return res;
        while(!(que.empty())){
        	int size = que.size();
            vector<int> temp;
        	while(size--){
            	TreeNode* node = que.front();
            	que.pop();
            	temp.push_back(node->val);
                if(node->left) que.push(node->left);
            	if(node->right)	que.push(node->right);                
        	}
            int last = temp.back();//由于只看最右边的元素，所以是每层最右侧的节点元素
            res.push_back(last);
        }
        return res;
    }
};

力扣637题 二叉树的层平均值

​ 给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。

637.二叉树的层平均值

​ 代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
	// double GetAverage(vector<int> vec){
    //     double sum = 0;        
    //     for(int i = 0; i < vec.size(); i++){

    //         sum = sum + vec[i];
    //     }
    //     double ave = sum/vec.size();
    //     return ave;
    // };
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> que;//定义队列来存放二叉树节点
        vector<double> res;
        if(root != NULL)	que.push(root);
        else return res;
        while(!(que.empty())){//队列非空时，持续进行遍历操作，当队列为空的时候说明所有的节点元素均已弹出
        	int size = que.size();
            double sum = 0;
        	for(int i = 0;i < size; i++){
            	TreeNode* node = que.front();
            	que.pop();
            	sum += node->val;
            	if(node->left)	que.push(node->left);
            	if(node->right)	que.push(node->right);
        	}
            res.push_back(sum / size);//无须额外定义求平均值的函数，直接push_back即可
        }
        return res;
    }
};

力扣429题 N叉树的层序遍历

​ 给定一个 N 叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。

​ 例如，给定一个 3叉树 :

429. N叉树的层序遍历

​ 返回其层序遍历:

​ [ [1], [3,2,4], [5,6] ]

​ 代码如下：

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;//此处修改了树节点的定义，每个节点下面可以有多个用数组存放的子节点

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*> que;//定义队列来存放二叉树节点
        vector<vector<int>> res;//定义二维数组来存放每一层的节点
        if(root != NULL)	que.push(root);
        else return res;
        while(!(que.empty())){//队列非空时，持续进行遍历操作，当队列为空的时候说明所有的节点元素均已弹出
        	int size = que.size();
            vector<int> temp;
        	while(size--){
            	Node* node = que.front();
            	que.pop();
            	temp.push_back(node->val);
                for(int i = 0; i < node->children.size();i++){
                    if(node->children[i])   que.push(node->children[i]);
                }
        	}
            res.push_back(temp);
        }
        return res;
    }
};

力扣515题 在每个栈中找最大值

​ 您需要在二叉树的每一行中找到最大的值。

515.在每个树行中找最大值

​ 代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;//定义队列来存放二叉树节点
        vector<int> res;
        if(root != NULL)	que.push(root);
        else return res;
        while(!(que.empty())){//队列非空时，持续进行遍历操作，当队列为空的时候说明所有的节点元素均已弹出
        	int size = que.size();
            int MaxNum = INT_MIN;//取最小值进行比较，得到每一层的最大值
        	for(int i = 0; i < size; i++){
            	TreeNode* node = que.front();
            	que.pop();
            	MaxNum = MaxNum > node->val ? MaxNum : node->val;
            	if(node->left)	que.push(node->left);
            	if(node->right)	que.push(node->right);
        	}
            res.push_back(MaxNum);
        }
        return res;
    }
};

力扣116题 填充每个节点的下一个右侧节点指针

​ 给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

​ 填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

​ 初始状态下，所有 next 指针都被设置为 NULL。

116.填充每个节点的下一个右侧节点指针

​ 和之前不一样的是，这里的头节点需要特殊处理，提前取出来，其他所有的节点处理方式一样；

​ 具体代码实现如下：

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root != NULL) que.push(root);
        else return NULL;
        while(!(que.empty())){
            int size = que.size();
            Node* node;
            Node* nodePre;
            for(int i = 0;i < size; i++){
                if(i == 0){//单独对根节点进行记录
                    nodePre = que.front();
                    que.pop();
                    node = nodePre;
                }
                else{
                    node = que.front();
                    que.pop();
                    nodePre->next = node;//nodePre是一个指向当前层级的前一个节点的指针
                    nodePre = nodePre->next;
                }
                if(node->left)  que.push(node->left);
                if(node->right) que.push(node->right);
            }
            nodePre->next = NULL;
        }   
        return root;
    }
};

​ 这道题，写的时候人麻了……

​ 这能卡我半个小时的……

​ 记录下来思维卡壳状态下的思路：

​ 将当前节点node的next指针指向nodePre；

​ 再将nodePre更新为当前节点node，即nodePre = nodePre->next;

​ 但是这里为什么叫nodePre前一个节点？？？以例子为例的话第二次for循环处理以后，第一次得到的node是元素值为2的节点，那这个节点的前一个节点是什么？不应该没有东西吗？

​ 很简单啊……

​ nodePre存放的地址不会因为else语句的结束而被清除，nodePre的声明在循环外面，这个nodePre实际起的作用是一个临时存储指针node_temp的作用；所以nodePre完成对第一个层内节点的存储以后，再次进入for循环的时候nodePre存储的就是第一个层内节点，这样就能够实现左右节点相链接从而达到题目要求。

力扣117题 填充每个节点的下一个右侧节点指针Ⅱ

​ 除了不是完美二叉树以外，和上道题思路代码都是一致，不再赘述。

力扣104题 二叉树的最大深度

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

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

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

示例：

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

104. 二叉树的最大深度

返回它的最大深度 3

​ 很简单的题，深度优先遍历，depth++：

class Solution{
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        int depth = 0;
        if(root == NULL)	return 0;
        que.push(root);
        while(!(que.empty())){
            int size = que.size();
            depth++; // 记录深度
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
            	if (node->right) que.push(node->right);
        	}
        }
        return depth;
    }
};

力扣111题 二叉树的最小深度

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

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

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

示例 1：

img

输入：root = [3,9,20,null,null,15,7]
输出：2

​ 一样的思路，但是返回条件不同，最大深度是所有的节点的叶节点均为空的时候返回；而最小深度是再第一次遍历到叶节点均为空的时候就直接return；

class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()) {
            int size = que.size();
            depth++; // 记录最小深度
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
                if (!node->left && !node->right) { // 当左右孩子都为空的时候，说明是最低点的一层了，退出
                    return depth;
                }
            }
        }
        return depth;
    }
};

翻转二叉树

​ 搞清楚自己代码实现的逻辑底层是什么！

​ 先用递归实现：

​ 1.确定递归函数的返回值和参数：TreeNode* ReverseTree(TreeNode* root){};

​ 2.确定遍历终止条件：if(root == NULL) return root;

​ 3.确认单层递归逻辑：

​

​ 前序遍历：中左右；

​ 处理逻辑：swap(root->left,root->right)//此处root指的是遍历的每一个节点，不是根节点

​ 即：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        swap(root->left, root->right);  // 中
        invertTree(root->left);         // 左
        invertTree(root->right);        // 右
        return root;
    }
};

​ 后序遍历：左右中；

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        invertTree(root->left);         // 左
        invertTree(root->right);        // 右
        swap(root->left, root->right);  // 中
        return root;
    }
};

​ 中序呢，左中右行吗？

​ 可以实现类似于中序的写法，但是实际操作是“左中左”；

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        invertTree(root->left);         // 左
        swap(root->left, root->right);  // 中
        invertTree(root->left);         // 左
        return root;
    }
};

​ 其余的写法明天再补吧，今天有点累了；

对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。

示例 1：

img

输入：root = [1,2,2,3,4,4,3]
输出：true

示例 2：

img

输入：root = [1,2,2,null,3,null,3]
输出：false

​ 还是确定遍历顺序，不要稀里糊涂！

​ 由于这道题需要不断对比左右孩子的信息返回给上一个节点，才能知道左右节点是否是相互翻转的；

​ 只有后序遍历，才能将左右孩子的信息返回回上一层;

​ 1.确认递归函数类型和返回值：bool compare(TreeNode* left , TreeNode* right);

​ 2.确定终止条件：

​ 要么左子树为空，右子树不为空 return false;

​ 要么右子树为空，左子树不为空 return false;

​ 要么左右都不为空 return true;

​ 要么左右都不为空但不等 return false;

​ 要么左右都不为空且相等 执行第三步单层递归逻辑；

​ 3.单层递归逻辑：

​ 我们需要对左子树和右子树的子节点进行比较：外侧和内侧

​ bool outside = compare(left->left , right->right); //左子树：左 右子树：右

​ bool inside = compare(left->right , right->left); //左子树：右 右子树：左

​ bool res = outside && inside; //左子树：中 右子树：中

​ 则可以得到递归函数：

    bool compare(TreeNode* left, TreeNode* right) {
        // 首先排除空节点的情况
        if (left == NULL && right != NULL) return false;
        else if (left != NULL && right == NULL) return false;
        else if (left == NULL && right == NULL) return true;
        // 排除了空节点，再排除数值不相同的情况
        else if (left->val != right->val) return false;

        // 此时就是：左右节点都不为空，且数值相同的情况
        // 此时才做递归，做下一层的判断
        bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
        bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左
        bool isSame = outside && inside;                    // 左子树：中、 右子树：中 （逻辑处理）
        return isSame;
    }

​ 整体代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right) {
        // 首先排除空节点的情况
        if (left == NULL && right != NULL) return false;
        else if (left != NULL && right == NULL) return false;
        else if (left == NULL && right == NULL) return true;
        // 排除了空节点，再排除数值不相同的情况
        else if (left->val != right->val) return false;

        // 此时就是：左右节点都不为空，且数值相同的情况
        // 此时才做递归，做下一层的判断
        bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
        bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左
        bool isSame = outside && inside;                    // 左子树：中、 右子树：中 （逻辑处理）
        return isSame;

    }
    bool isSymmetric(TreeNode* root) {
        if(root == NULL)    return false;
        bool res = compare(root->left,root->right);
        return res;
    }
};
Salinoia
关注
  • 33
    点赞
  • 踩
  • 51
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java-leetcode题解之第107题二叉树的层序遍历II.zip
06-18
本压缩包文件“java-leetcode题解之第107题二叉树的层序遍历II.zip”显然是针对LeetCode上的第107题的一个解决方案，该题目涉及到二叉树的层序遍历，但有一个特殊的变体。下面我们将深入探讨这个知识点。 首先，...
二叉树的层序遍历 II.md
11-17
二叉树的层序遍历 II.md
c语言leetcode题解之第107题二叉树的层序遍历II.zip
07-13
c c语言leetcode题解之第107题二叉树的层序遍历II
12-3 LeetCode：226. 翻转二叉树.mp4
05-30
12-3 LeetCode：226. 翻转二叉树.mp4
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 915
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
2.6基本算法之动态规划6045:开餐馆
Andy_SCP001的博客
07-24 226
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 211
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
算法-KMP字符串匹配
xx_xb的博客
07-23 292
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
代码随想录算法训练营第二十二天|回溯算法part01
最新发布
qq_43456971的博客
07-25 612
这一题与上题一样，除了终止条件中需要判断和是否为target。多了一个剪枝操作，就是当值已经大于target，直接返回。本题还有一个建立数字和字母之间映射的问题，使用string数组来进行映射。因此回溯算法的宽度是每个集合里面的个数，回溯算法的深度是集合的个数。参数是digits与index，index是用来记录遍历第几个集合。在单个集合1-9中，寻找所有个数为k且和为target的组合。在单个集合1-n中，寻找所有个数为k的组合。这一题是在多个集合中找所有可能的组合。和所有递归一样，都有三部曲。
2766. 重新放置石块 Medium
珞米的博客
07-24 528
第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，有石块的位置为 [2,2,3,3]。第 i = 1 步操作中，我们将位置 3 处的石块移到位置 2 处，有石块的位置为 [2,2,2,2]。第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，位置 2,6,7,8 有石块。第 i = 1 步操作中，我们将位置 7 处的石块移到位置 9 处，位置 2,6,8,9 有石块。第 i = 2 步操作中，我们将位置 2 处的石块移到位置 5 处，位置 5,6,8,9 有石块。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 276
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
算法题目整合5
qq_62571233的博客
07-23 923
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
贪心加暴力枚举
wniuniu_的博客
07-24 253
所以我们可以直接暴力枚举，然后我们知道假操作一定是在最开始进行，至于加多少次我们可以直接枚举。
2.6基本算法之动态规划2989:糖果
Andy_SCP001的博客
07-24 412
糖果公司的N件产品每件都包含数量不同的糖果。Dzx希望他选择的产品包含的糖果总数是K的整数倍，这样他才能平均地将糖果分给帮助他维护世界和平的伙伴们。/*边界条件:dp[i][j]初始化为负无穷,int dp[1005][1005];//dp[i][j]:从i种糖果中选,组成糖果总数量k的倍数。dp[0][0]=0;//dp[0][0]边界条件:0种糖果组成糖果总数量0的倍数是0。另外,必须保证所有的状态是由dp[0][0]转移过来的*/除了dp[0][0]为0,因为我们这里求的是最大值,
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
danaaaa的博客
07-24 1050
二叉搜索树向左或向右指明方向，不用遍历整个树。
Python鲁汶意外莱顿复杂图拓扑分解算法
跨学科知识视角展现
07-24 1084
:dart:算法池化和最佳分区搜索：:pen:网格搜索 | :pen:发现算法池 | :pen:返回指定图的最佳划分 | :pen:返回指定图的最佳分区 | :dart:适应度和聚类比较功能：:pen:图的划分 | :pen:节点度 | :pen:给定算法检测到社群总数 | :pen:图密度 | :pen:社群顶点的度数之和 | :pen:解之间的预期一致 | :pen:联合熵 | :pen:平均内部度、所有可能的节点对的平均路径长度 | :pen:节点指向社群外的边平均比例 | :pen:现有边距离社群比
【算法】分割回文串
时清云的博客
07-24 355
难度：中等。
【常微分方程】
qq_74285286的博客
07-24 368
常微分方程笔记
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列。 引用中给出了一个实现翻转二叉树的代码示例。该代码使用了递归法的前序遍历，对于每一个节点，交换其左右子节点，然后递归地对其左右子树进行翻转。 引用中给出了一个实现二叉树的层序遍历的代码示例。该代码使用了BFS的思想，借助队列来实现层序遍历。每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列，同时将当前层的节点值添加到结果列表中。 综上所述，参考这些引用，可以通过BFS来实现二叉树的层序遍历，并通过递归法或迭代法来翻转二叉树。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值