LeetCode刷题day12||二叉树层序遍历&&226.翻转二叉树&&101. 对称二叉树--二叉树

最新推荐文章于 2024-07-13 18:57:33 发布
最新推荐文章于 2024-07-13 18:57:33 发布
阅读量172 收藏
点赞数
分类专栏： leetcode 文章标签： leetcode 算法 深度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangjianhs/article/details/127309768
版权

文章目录

二叉树层序遍历

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;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            for (int i = 0; i < size; i++) {
                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;

    }
};

递归法

/**
 * 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:
    void order(TreeNode* cur, vector<vector<int>>& result, int depth) {
        if (cur == nullptr) return;
        if (result.size() == depth) result.push_back(vector<int>());
        result[depth].push_back(cur->val);
        order(cur->left, result, depth + 1);
        order(cur->right, result, depth + 1);
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        int depth = 0;
        order(root, result, depth);
        return result;
    }
};

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;
        if (root != nullptr) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            for (int i = 0; i < size; i++) {
                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);

        }
        reverse(result.begin(),result.end());
        return result;

    }
};

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;
        if (root != nullptr) que.push(root);
        vector<int> result;
        while (!que.empty()) {
            int size = que.size();
            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 (i == size - 1) result.push_back(node->val);
            }
        }
        return result;

    }
};

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:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != nullptr) que.push(root);
        vector<double> result;
        while (!que.empty()) {
            double sum = 0;
            int size = que.size();
            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);
            }
            result.push_back(sum / size);
        }
        return result;

    }
};

429. N 叉树的层序遍历

在这里插入图片描述
题目链接

/*
// 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;
        if (root != nullptr) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            for (int i = 0; i < size; ++i) {
                Node* node = que.front();
                que.pop();
                vec.push_back(node->val);
                for (Node* chil : node->children){
                    que.push(chil);
                }
            }
            result.push_back(vec);
        }
        return result;

    }
};

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;
        if (root != nullptr) que.push(root);
        vector<int> result;
        while (!que.empty()) {
            int size = que.size();
            int maxValue = INT_MIN;
            for (int i = 0; i < size; ++i) {
                TreeNode* node = que.front();
                que.pop();
                maxValue = max(maxValue,node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(maxValue);
        } 
        return result;

    }
};

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);
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; ++i) {
                Node* cur = que.front();
                que.pop();
                if (i < size - 1) {
                    cur->next = que.front();
                }
                if (cur->left) que.push(cur->left);
                if (cur->right) que.push(cur->right);
             }
        }
        return root;
    }
};

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

在这里插入图片描述
在这里插入图片描述

题目链接

/*
// 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);
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size;i++) {
                Node* node = que.front();
                que.pop();
                if (i < size - 1) {
                    node->next = que.front();
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return root;
        
    }
};

104. 二叉树的最大深度

在这里插入图片描述
题目链接

/**
 * 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:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != nullptr) que.push(root);
        int result = 0;
        while (!que.empty()) {
            int size = que.size();
            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);
            }
            result++;
        }
        return result;
    }
};

111.二叉树的最小深度

在这里插入图片描述
题目链接

/**
 * 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:
    int minDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if (root == nullptr) return 0;
        que.push(root);
        int result = 1;
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++){
                TreeNode* node = que.front();
                que.pop();
                if ((!node->left) && (!node->right)) return result;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
                if (i == size - 1) result++;
            }
        }
        return result;
    }
};

class Solution {
public:
    int minDepth(TreeNode *root) {
        if (root == nullptr) return 0;
        queue<pair<TreeNode *, int> > que;
        que.emplace(root, 1);
        while (!que.empty()) {
            TreeNode *node = que.front().first;
            int depth = que.front().second;
            que.pop();
            if (!node->left && !node->right) return depth;
            if (node->left) que.emplace(node->left, depth + 1);
            if (node->right) que.emplace(node->right, depth + 1);
        }
        return 0;
    }
};

226.翻转二叉树

题目描述

在这里插入图片描述

题目链接

思路分析

这道题目使用前序遍历和后序遍历都可以，唯独中序遍历不方便，因为中序遍历会把某些节点的左右孩子翻转了两次！

代码

  • 递归（前序）
/**
 * 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:
    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr) return root;
        swap(root->left, root->right);
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};
  • 广度优先遍历
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                swap(node->left, node->right); // 节点处理
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return root;
    }
};
  • 深度优先遍历
    前序
/**
 * 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:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        stack<TreeNode*> st;
        st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            swap(node->left, node->right);
            if (node->right) st.push(node->right);
            if (node->left) st.push(node->left);
        }
        return root;

    }
};

统一迭代法

/**
 * 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:
    TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*> st;
        if (root != nullptr) 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();
                swap(node->left, node->right);
            }
        }
        return root;
    }
};

101. 对称二叉树

题目描述

在这里插入图片描述
题目链接

思路分析

对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树。
在这里插入图片描述

代码

  • 递归法
/**
 * 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;
        else return compare(left->left, right->right) && compare(left->right, right->left);
    }
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        return compare(root->left, root->right);
    }
};
  • 迭代法
    使用队列
/**
 * 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 isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        queue<TreeNode*> que;
        que.push(root->left);
        que.push(root->right);
        while (!que.empty()) {
            TreeNode* leftNode = que.front(); que.pop();
            TreeNode* rightNode = que.front(); que.pop();
            if (!leftNode && !rightNode) continue;
            if ((!leftNode) || (!rightNode) || (leftNode->val != rightNode->val)) return false;
            que.push(leftNode->left);
            que.push(rightNode->right);
            que.push(leftNode->right);
            que.push(rightNode->left);
        }
        return true;

    }
};

使用栈
这个迭代法，其实是把左右两个子树要比较的元素顺序放进一个容器，然后成对成对的取出来进行比较，那么其实使用栈也是可以的。

/**
 * 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 isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        stack<TreeNode*> st;
        st.push(root->left);
        st.push(root->right);
        while (!st.empty()) {
            TreeNode* leftNode = st.top(); st.pop();
            TreeNode* rightNode = st.top(); st.pop();
            if (!leftNode && !rightNode) continue;
            if ((!leftNode) || (!rightNode) || (leftNode->val != rightNode->val)) return false;
            st.push(leftNode->left);
            st.push(rightNode->right);
            st.push(leftNode->right);
            st.push(rightNode->left);
        }
        return true;

    }
};
Kl_WJ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代码随想录 | Day15 | 二叉树：递归遍历&&迭代遍历&&层序遍历
m0_74795952的博客
06-03 733
主要学习内容：1.二叉树递归遍历2.二叉树迭代遍历3.二叉树层序遍历来自。
刷题DAY15 | 102-二叉树的层序遍历 226-翻转二叉树 101-对称二叉树
wangs29的博客
03-07 892
对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树。因为我们要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。正是因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。
LeetCode Java刷题笔记—102. 二叉树的层序遍历
终生学习践行者
02-19 610
LeetCode Java刷题笔记—102. 二叉树的层序遍历
代码随想录刷题day15 | 102.二叉树的层序遍历(10)、226.翻转二叉树、101.对称二叉树
weixin_40323978的博客
10-26 209
代码随想录刷题day15
代码随想录算法训练营第15天 | LeetCode 102. 二叉树的层序遍历，226.翻转二叉树，101.对称二叉树
a976903676的博客
11-09 190
LeetCode 102. 二叉树的层序遍历，226.翻转二叉树，101.对称二叉树
python-leetcode面试题解之第102题二叉树的层序遍历-题解.zip
04-29
本题解将详细探讨Python实现的LeetCode第102题——二叉树的层序遍历。层序遍历，也称为广度优先搜索（BFS），是处理二叉树问题的一种常见策略。 **二叉树的概念** 二叉树是一种特殊的图结构，每个节点最多有两个子...
java-leetcode题解之第107题二叉树的层序遍历II.zip
06-18
本压缩包文件“java-leetcode题解之第107题二叉树的层序遍历II.zip”显然是针对LeetCode上的第107题的一个解决方案，该题目涉及到二叉树的层序遍历，但有一个特殊的变体。下面我们将深入探讨这个知识点。 首先，...
python-leetcode面试题解之第103题二叉树的锯齿形层序遍历-题解.zip
04-29
本篇内容将深入解析Python在解决LeetCode第103题——“二叉树的锯齿形层序遍历”时的具体方法和思路。 首先，我们需要理解什么是“锯齿形层序遍历”。在二叉树的层次遍历过程中，常规的层次遍历是按照每一层从左到...
java-leetcode题解之第102题二叉树的层序遍历.zip
06-18
层次遍历，又称为二叉树的层序遍历，是指按照从上到下、从左到右的顺序逐层访问二叉树的所有节点。这个过程可以借助于队列的数据结构来实现。 在Java中，我们可以创建一个队列来存储二叉树的节点，首先将根节点入队...
python-leetcode面试题解之第107题二叉树的层序遍历II.zip
04-29
本题解针对LeetCode上的第107题，即“二叉树的层序遍历II”，我们将深入探讨该问题的背景、解决方案以及它在面试中的重要意义。 二叉树是计算机科学中一种基本的数据结构，由节点组成，每个节点最多有两个子节点，...
leetcode--恢复二叉搜索树
liulanba的博客
07-09 467
给你二叉搜索树的根节点 root ，该树中的 恰好 两个节点的值被错误地交换。请在不改变其结构的情况下，恢复这棵树。示例 1：输入：root = [1,3,null,null,2]输出：[3,1,null,null,2]解释：3 不能是 1 的左孩子，因为 3 > 1。交换 1 和 3 使二叉搜索树有效。示例 2：输入：root = [3,1,4,null,null,2]输出：[2,1,4,null,null,3]解释：2 不能在 3 的右子树中，因为 2 < 3。
leetcode--验证二叉搜索树
liulanba的博客
07-09 660
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。有效 二叉搜索树定义如下：节点的左子树只包含 小于 当前节点的数。节点的右子树只包含 大于 当前节点的数。所有左子树和右子树自身必须也是二叉搜索树。示例 1：输入：root = [2,1,3]输出：true示例 2：输入：root = [5,1,4,null,null,3,6]输出：false解释：根节点的值是 5 ，但是右子节点的值是 4。提示：树中节点数目范围在[1, 104] 内。
leetcode--从中序与后序遍历序列构造二叉树
liulanba的博客
07-09 635
给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树。
力扣-bfs
weixin_63551790的博客
07-12 434
何为广度优先搜索？广度优先搜索，即bfs。不同于dfs（走到底然后再换另外一条路），bfs更像是一层一层的走。常常用来处理最短路径问题。
leetcode704.二分查找
欢迎来到我的博客~
07-12 213
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。输入: nums = [-1,0,3,5,9,12], target = 9。输入: nums = [-1,0,3,5,9,12], target = 2。解释: 9 出现在 nums 中并且下标为 4。解释: 2 不存在 nums 中因此返回 -1。
LeetCode 面试题02.04.分割链表
最新发布
m0_63816268的博客
07-13 189
一段放小于x的值，另一段放大于x的值。开辟四个指针lesshead、lesstail、greaterhead、greatertail，head为哨兵位，防止链表为空时情况过于复杂，tail为尾结点，将链表的值进行大小判断后。完成分段，分段后再链接，最后释放哨兵位完成整个链表的分割。
LeetCode --- 2108. Find First Palindromic String in the Array 解题报告
杨鑫newlife的专栏
07-09 1089
Given an array of strings , return the first palindromic string in the array. If there is no such string, return an empty string .A string is palindromic if it reads the same forward and backward.Example 1: Input: words = ["abc","car",&
LeetCode分发糖果(贪心思路分析)
m0_74301606的博客
07-12 176
题目描述。
【LeetCode】12. 小张刷题计划
说文科技，做有态度的研究。
07-09 299
稳住，能赢！没有经验的同学在面试岗位的时候，总是显得手忙脚乱，所以多练习，把技能提升，眼界提升，接着心态放平和，不要慌张，把面试题目读懂读透彻就会大大提升赢的概率。其实本题就是一道二分法解决的题目，只不过这里的二分法多了一个限制条件。
递归实现二叉树的层序遍历
12-19
<<引用[1]：https://leetcode＊＊＊-order-traversal/solution/di-gui-python-by-jason-2/。引用：https://www.geeksforgeeks.org/level-order-tree-traversal/。引用：https://www.tutorialspoint.com/data_structures_algorithms/tree_traversal.htm。>> 以下是使用递归实现二叉树的层序遍历的Python代码示例： ```python class TreeNode: def __init__(self, value=0, left=None, right=None): self.value = value self.left = left self.right = right def levelOrderTraversal(root): result = [] def helper(node, level): if node: if len(result) < level + 1: result.append([]) result[level].append(node.value) helper(node.left, level + 1) helper(node.right, level + 1) helper(root, 0) return result ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值