C++算法题 - 二叉树（1）

x_fengmo

已于 2024-04-26 12:34:30 修改

阅读量719

点赞数 27

分类专栏：力扣算法文章标签： c++ 算法

于 2024-04-26 12:33:31 首次发布

本文链接：https://blog.csdn.net/x_fengmo/article/details/138205681

版权

力扣算法专栏收录该内容

13 篇文章 0 订阅

订阅专栏

104. 二叉树的最大深度

LeetCode_link

给定一个二叉树 root ，返回其最大深度。

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

示例 1：
在这里插入图片描述
输入：root = [3,9,20,null,null,15,7]
输出：3

示例 2：
输入：root = [1,null,2]
输出：2

提示：
树中节点的数量在 [0, 104] 区间内。
-100 <= Node.val <= 100

思路：递归

/**
 * 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) {
        if(root == nullptr) return 0;
        return 1 + max(maxDepth(root->left), maxDepth(root->right));
    }
};

100. 相同的树

LeetCode_link

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1：
在这里插入图片描述
输入：p = [1,2,3], q = [1,2,3]
输出：true

示例 2：
在这里插入图片描述
输入：p = [1,2], q = [1,null,2]
输出：false

示例 3：
在这里插入图片描述
输入：p = [1,2,1], q = [1,1,2]
输出：false

提示：
两棵树上的节点数目都在范围 [0, 100] 内
-10^4 <= Node.val <= 10^4

思路：递归

/**
 * 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 isSameTree(TreeNode* p, TreeNode* q) {
        if(p == nullptr && q == nullptr)    return true;
        if(p == nullptr || q == nullptr || p->val != q->val){
            return false;
        }
        return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);

    }
};

226. 翻转二叉树

LeetCode_link

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：
在这里插入图片描述
输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

示例 2：
在这里插入图片描述
输入：root = [2,1,3]
输出：[2,3,1]

示例 3：
输入：root = []
输出：[]

提示：
树中节点数目范围在 [0, 100] 内
-100 <= Node.val <= 100

思路：递归

/**
 * 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 nullptr;
        invertTree(root->left);
        invertTree(root->right);
        TreeNode *temp = root->left;
        root ->left = root->right;
        root->right = temp;
        return root;
    }
};

101. 对称二叉树

LeetCode_link

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

示例 1：
在这里插入图片描述
输入：root = [1,2,2,3,4,4,3]
输出：true

示例 2：
在这里插入图片描述
输入：root = [1,2,2,null,3,null,3]
输出：false

提示：
树中节点数目在范围 [1, 1000] 内
-100 <= Node.val <= 100

思路：递归

/**
 * 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) {
        return check(root, root);
    }
    bool check(TreeNode* l, TreeNode* r){
        if(l == nullptr || r == nullptr){
            if(l != r)   return false;
            else    return true;
        }
        return l->val != r->val ? false : check(l->left, r->right) && check(l->right, r->left);
    }
};

105. 从前序与中序遍历序列构造二叉树

LeetCode_link

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

示例 1:
在这里插入图片描述
输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]

示例 2:
输入: preorder = [-1], inorder = [-1]
输出: [-1]

提示:
1 <= preorder.length <= 3000
inorder.length == preorder.length
-3000 <= preorder[i], inorder[i] <= 3000
preorder 和 inorder 均 无重复 元素
inorder 均出现在 preorder
preorder 保证为二叉树的前序遍历序列
inorder 保证为二叉树的中序遍历序列

思路：

/**
 * 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* buildTree(vector<int> &preorder, vector<int>& inorder) {
        int n = inorder.size();
        if(n == 0)  return nullptr;

        int root = 0;
        while(root < n){
            if(inorder[root] == preorder[0])   break;
            root++;
        }

        vector<int> pre_l(preorder.begin()+1,preorder.begin()+root+1);
        vector<int> in_l(inorder.begin(), inorder.begin()+root);
        TreeNode* left = buildTree(pre_l, in_l);

        vector<int> pre_r(preorder.begin()+root+1,preorder.end());
        vector<int> in_r(inorder.begin()+root+1, inorder.end());
        TreeNode* right = buildTree(pre_r, in_r);

        TreeNode* node = new TreeNode(preorder[0], left, right);
        return node;
    }
};

106. 从中序与后序遍历序列构造二叉树

LeetCode_link

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。

示例 1:
在这里插入图片描述
输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
输出：[3,9,20,null,null,15,7]

示例 2:
输入：inorder = [-1], postorder = [-1]
输出：[-1]

提示:
1 <= inorder.length <= 3000
postorder.length == inorder.length
-3000 <= inorder[i], postorder[i] <= 3000
inorder 和 postorder 都由不同的值组成
postorder 中每一个值都在 inorder 中
inorder 保证是树的中序遍历
postorder 保证是树的后序遍历

思路：

/**
 * 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* buildTree(vector<int>& inorder, vector<int>& postorder) {
        int n = inorder.size();
        if(n == 0)  return nullptr;
        int root = 0;
        while(inorder[root] != postorder[n-1]){
            root ++;
        }

        vector<int> in_l(inorder.begin(), inorder.begin() + root);
        vector<int> post_l(postorder.begin(), postorder.begin() + root);
        TreeNode* left = buildTree(in_l,post_l);

        vector<int> in_r(inorder.begin() + root + 1, inorder.end());
        vector<int> post_r(postorder.begin() + root, postorder.end() -1);
        TreeNode* right = buildTree(in_r, post_r);

        TreeNode* node = new TreeNode(inorder[root], left, right);
        return node;
    }
};

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

LeetCode_link

给定一个二叉树：

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

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

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

示例 1：
在这里插入图片描述
输入：root = [1,2,3,4,5,null,7]
输出：[1,#,2,3,#,4,5,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），‘#’ 表示每层的末尾。

示例 2：
输入：root = []
输出：[]

提示：
树中的节点数在范围 [0, 6000] 内
-100 <= Node.val <= 100

思路：层遍历，用队列

/*
// 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*> q;
        Node* right = root;
        Node * n = root;
        q.push(n);
        while(right != NULL){
            n = q.front();
            q.pop();
            if(n->left != NULL) q.push(n->left);
            if(n->right != NULL)    q.push(n->right);
            if(n == right){
                n->next = NULL;
                if(!q.empty())  right = q.back();
                else    right = NULL;
            }else{
                n->next = q.front();
            }
        }
        return root;
    }
};