LeetCode 有关二叉树的算法题目（C++）

原创 于 2020-06-18 11:55:03 发布 · 490 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了LeetCode中关于二叉树的各种遍历算法，包括前序、中序、后序遍历的递归和非递归实现，以及层序遍历和相关问题，如平衡二叉树、对称二叉树等，并提供了C++代码示例和运行截图。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

0、NULL与nullptr的区别

在C语言中，NULL通常被定义为：#define NULL ((void *)0)。因为在C语言中把空指针赋给int和char指针的时候，发生了隐式类型转换，把void指针转换成了相应类型的指针。

所以说NULL实际上是一个空指针。在C++中，NULL实际上是0。因为C++中不能把void*类型的指针隐式转换成其他类型的指针。

在C++11版本中特意引入了nullptr这一新的关键字可以保证在任何情况下都代表空指针，以后用nullptr替代NULL，而NULL就当做0使用。

1、二叉树的前序遍历

问题描述

给定一个二叉树，返回它的 前序 遍历。

示例:

输入: [1,null,2,3]  
   1
    \
     2
    /
   3 

输出: [1,2,3]

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> ivec;
    vector<int> preorderTraversal(TreeNode* root) {
        if(root){
            ivec.push_back(root->val);
            if(root->left)
                preorderTraversal(root->left);
            if(root->right)
                preorderTraversal(root->right);
        }
        return ivec;
    }
};

运行截图

在这里插入图片描述

先序遍历的非递归算法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        if(root == NULL)
            return {};
        stack<TreeNode*> s;
        vector<int> v;
       TreeNode* p = root;
       while(p or s.size()){
           if(p){
               v.push_back(p->val);
               s.push(p);
               p = p->left;
           }
           else{
               p = s.top();
               s.pop();
               p = p->right;
           }
       }
        return v;
    }
};

运行截图

在这里插入图片描述

2、二叉树的中序遍历

问题描述

给定一个二叉树，返回它的中序 遍历。

示例:

输入: [1,null,2,3]
   1
    \
     2
    /
   3

输出: [1,3,2]

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> ivec;
    vector<int> inorderTraversal(TreeNode* root) {
        if(root){
            if(root->left)
                inorderTraversal(root->left);
            ivec.push_back(root->val);
            if(root->right)
                inorderTraversal(root->right);
        }
        return ivec;
    }
};

运行截图

在这里插入图片描述

二叉树中序遍历非递归算法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        if(root == NULL)
            return {};
        stack<TreeNode*> s;
        vector<int> v;
        TreeNode* p = root;
        while(p or s.size()){
            if(p){
                s.push(p);
                p = p->left;
            }
            else{
                p = s.top();
                s.pop();
                v.push_back(p->val);
                p = p->right; 
            }
        }
        return v;
    }
};

运行截图

在这里插入图片描述

3、二叉树的后序遍历

问题描述

给定一个二叉树，返回它的 后序 遍历。

示例:

输入: [1,null,2,3]  
   1
    \
     2
    /
   3 

输出: [3,2,1]

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> ivec;
    vector<int> postorderTraversal(TreeNode* root) {
        if(root){
            if(root->left)
                postorderTraversal(root->left);
            if(root->right)
                postorderTraversal(root->right);
            ivec.push_back(root->val);
        }
        return ivec;
    }
};

运行截图

在这里插入图片描述

二叉树后序遍历的非递归算法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        if(root == NULL)
            return {};
        stack<TreeNode*> s;
        vector<int> v;
        TreeNode *p = root, *pre = NULL;
        while(p or s.size()){
            if(p){
                s.push(p);
                p = p->left; 
            }
            else{
                p = s.top();
                if(p->right && pre != p->right){
                    p = p->right;
                }
                else{
                    v.push_back(p->val);
                    s.pop();
                    pre = p;
                    p = NULL;
                }
            }
        }
        return v;
    }   
};

运行截图

在这里插入图片描述

4、二叉树的层序遍历

问题描述

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

示例：

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

    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果：

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

解题思路

  • 与以往的求二叉树的层序遍历略有不同。本题目的含义是将每层的二叉树结点存储到二维数组中。
  • 就可以利用一个整型变量记录此时的队列中的元素个数，也就是某一层的元素个数。
  • 当队头元素的孩子结点入队后，队头元素出队，记录元素个数的变量减一，直到该变量减为0，说明某一层的结点全部出队。
  • 循环直到队列中没由元素为止。

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        if(root == NULL)
            return {};
        queue<TreeNode*> treeque; // 建立二叉树类型的队列
        vector<vector<int>> allLevelVec; //存储层序遍历的数组
        vector<int> eveLevelVec; // 存储每层的数组
        treeque.push(root); // 根结点入队
        while(treeque.size()){
            int num = treeque.size(); // 记录当前队列中的元素个数
            while(num){
                eveLevelVec.push_back(treeque.front()->val); // 队头元素进入容器
                num--; // 队列中元素个数减一
                if(treeque.front()->left) // 队头元素左孩子不空 入队
                    treeque.push(treeque.front()->left);
                if(treeque.front()->right) // 队头元素右孩子不空 入队
                    treeque.push(treeque.front()->right);
                treeque.pop(); // 队头元素出队
            }
            allLevelVec.push_back(eveLevelVec);
            eveLevelVec.clear();
        }
        return allLevelVec;
    }
};

运行截图

在这里插入图片描述

本题相似题解——二叉树的层平均值

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

示例 1:

输入:

    3
   / \
  9  20
    /  \
   15   7

输出: [3, 14.5, 11]
解释:
第0层的平均值是 3,  第1层是 14.5, 第2层是 11. 因此返回 [3, 14.5, 11].

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> dvec;
        queue<TreeNode*> q;
        q.push(root);
        while(q.size()){
            int num1 = q.size(), num2 = q.size();
            double d = 0;
            while(num1){
                d += q.front()->val;
                num1--;
                if(q.front()->left)
                    q.push(q.front()->left);
                if(q.front()->right)
                    q.push(q.front()->right);
                q.pop();
            }
            dvec.push_back(d/num2);
        }
        return dvec;
    }
};

运行截图

在这里插入图片描述

5、平衡二叉树（包含求二叉树高度）

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

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

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过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 。

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int GetTreeDepth(TreeNode* root) { // 求二叉树的高度
        if(root == NULL)
            return 0;
        int leftDepth = GetTreeDepth(root->left);
        int rightDepth = GetTreeDepth(root->right);
        return (leftDepth > rightDepth ? leftDepth : rightDepth) + 1;
    }
    bool isBalanced(TreeNode* root) {
        if(root == NULL)
            return true;
        bool leftBalance = true, rightBalance = true;
        if(abs(GetTreeDepth(root->left) - GetTreeDepth(root->right)) > 1)
            return false;
        leftBalance = isBalanced(root->left);
        rightBalance = isBalanced(root->right);
        return leftBalance && rightBalance;
    }
};

运行截图

在这里插入图片描述

6、对称二叉树

问题描述

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

例如，二叉树 [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

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isMirror(TreeNode* leftRoot, TreeNode* rightRoot){
        if(leftRoot == NULL && rightRoot == NULL) //左右孩子为空 符合镜像条件
            return true;
        if(leftRoot == NULL || rightRoot == NULL)// 一个空 一个不空 显然不符合题意
            return false;
        return leftRoot->val == rightRoot->val  // 左右孩子不空 结点值必须一致
        && isMirror(leftRoot->left, rightRoot->right)
        && isMirror(leftRoot->right, rightRoot->left);
    }
    bool isSymmetric(TreeNode* root) {
        if(root == NULL)
            return true;
        return isMirror(root->left, root->right);
    }            
};

在这里插入图片描述

7、二叉树的最小深度

问题描述

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

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

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

示例:

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

    3
   / \
  9  20
    /  \
   15   7

返回它的最小深度2。

解题思路

与求二叉树最大高度不同，求最小深度要考虑到单支树的最小高度不是1，而是有树枝的那边的高度。

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:

    int minDepth(TreeNode* root) {
        if(root == NULL)
            return 0;
        int minLeftDepth = minDepth(root->left);
        int minrightDepth = minDepth(root->right);
        if(root->left == NULL || root->right == NULL)
            return minLeftDepth + minrightDepth + 1;
        return min(minLeftDepth, minrightDepth) + 1;
    }   
};

运行截图

在这里插入图片描述

8、二叉树的直径

给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。

示例 :
给定二叉树

          1
         / \
        2   3
       / \     
      4   5

返回 3, 它的长度是路径[4,2,1,3]或者 [5,2,1,3]。

注意： 两结点之间的路径长度是以它们之间边的数目表示。

解题思路

与求树高的算法类似，树高是根结点到叶子结点的最多结点数。本题是求任意两点的最大连接边的数目，是有一定区别的。

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int maxdiameter(TreeNode* root, int &num){
        if(root == NULL)
            return 0;
        int l = maxdiameter(root->left, num);
        int r = maxdiameter(root->right, num);
        num = max(num, l + r);
        return max(l ,r) + 1;
    }
    int diameterOfBinaryTree(TreeNode* root) {
        int num = 0;
        maxdiameter(root, num);
        return num;
    }
};

运行截图

在这里插入图片描述

9、相同的树

问题描述

给定两个二叉树，编写一个函数来检验它们是否相同。

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

示例 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

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if(p == NULL and q == NULL)
            return true;
        if(p == NULL or q == NULL)
            return false;
        return p->val == q->val and isSameTree(p->left, q->left) and isSameTree(p->right, q->right);       
    }
};

运行截图

在这里插入图片描述

10、路径总和

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

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

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

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

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

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool hasPathSum(TreeNode* root, int sum) {
        if(root == NULL)
            return false;
        sum -= root->val;
        if(root->left == NULL and root->right == NULL)
            return sum == 0;
        return hasPathSum(root->left, sum) or hasPathSum(root->right, sum);

    }
};

运行截图

在这里插入图片描述

11、路径总和 II

问题描述

给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。

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

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

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

返回:

[
   [5,4,11,2],
   [5,8,4,5]
]

解题思路

以先序遍历思想为核心，没遍历一个结点均压入容器，遇到叶子结点后比较路径长度和sum值，记录所有符合题意的路径。

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isEqualSum(vector<int>& itmp, const int sum){
        if(itmp.size() == 0)
            return false;
        return accumulate(itmp.begin(), itmp.end(), 0) == sum;
    }

    void findPathNode(TreeNode* root, vector<vector<int>> &ivec, vector<int>& itmp, int sum){
        if(root){
            itmp.push_back(root->val);
            if(root->left == NULL and root->right == NULL and isEqualSum(itmp, sum))
                ivec.push_back(itmp);
            if(root->left)
                findPathNode(root->left, ivec, itmp, sum);
            if(root->right)
                findPathNode(root->right, ivec, itmp, sum);
        }
        if(itmp.size())
            itmp.pop_back();
    }
    
    vector<vector<int>> pathSum(TreeNode* root, int sum) { // 主函数
        if(root == NULL)
            return {};
        vector<vector<int>> ivec;
        vector<int> itmp; 
        findPathNode(root, ivec, itmp, sum);
        return ivec;             
    }
};

运行截图

在这里插入图片描述

12、二叉树的所有路径

问题描述

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

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

示例:

输入:

   1
 /   \
2     3
 \
  5

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

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

解题思路

  • 一定要注意被调用函数中的参数在什么情况下是引用传递，什么情况下是值传递。对于本题的写法，一定要用值传递。保证string s在每次迭代中的记忆性。
  • to_string()函数将变量转化为string类型。

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void allpaths(TreeNode* root, vector<string> &svec, string s){
        if(root){
            s += to_string(root->val);
            if(root->left == NULL and root->right == NULL)
                svec.push_back(s);
            else{
                s += "->";
                allpaths(root->left, svec, s);
                allpaths(root->right, svec, s);
            }
        }
        
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        if(root == NULL)
            return {};
        vector<string> svec;
        string s;
        allpaths(root, svec, s);
        return svec;      
    }
};

在这里插入图片描述

13、从前序与中序遍历序列构造二叉树

问题描述

根据一棵树的前序遍历与中序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历inorder = [9,3,15,20,7]
返回如下的二叉树：

    3
   / \
  9  20
    /  \
   15   7

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.empty() or inorder.empty())
            return nullptr;
        TreeNode* root = new TreeNode(preorder[0]);
        int pos = 0;
        for(; pos < preorder.size(); pos++)
            if(preorder[0] == inorder[pos])
                break;
        
        vector<int> preorder_left(preorder.begin() + 1, preorder.begin() + pos + 1);
        vector<int> preorder_right(preorder.begin() + pos + 1, preorder.end());
        vector<int> inorder_left(inorder.begin(), inorder.begin() + pos);
        vector<int> inorder_right(inorder.begin() + pos + 1, inorder.end());

        root->left = buildTree(preorder_left, inorder_left);
        root->right = buildTree(preorder_right, inorder_right);
        return root;
    }
};

运行截图

在这里插入图片描述

14、从中序与后序遍历序列构造二叉树

问题描述

根据一棵树的中序遍历与后序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

例如，给出

中序遍历inorder = [9,3,15,20,7]
后序遍历postorder = [9,15,7,20,3]
返回如下的二叉树：

    3
   / \
  9  20
    /  \
   15   7

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(inorder.empty() or postorder.empty())
            return nullptr;
        int n = postorder.size();
        TreeNode* root = new TreeNode(postorder[n - 1]);
        int pos = n - 1;
        for(; pos >= 0; pos--)
            if(inorder[pos] == postorder[n - 1])
                break;

        vector<int> inorder_left(inorder.begin(), inorder.begin() + pos + 1);
        vector<int> inorder_right(inorder.begin() + pos + 1, inorder.end());
        vector<int> postorder_left(postorder.begin(), postorder.begin() + pos);
        vector<int> postorder_right(postorder.begin() + pos, postorder.end() - 1);

        root->left = buildTree(inorder_left, postorder_left);
        root->right = buildTree(inorder_right, postorder_right);

        return root;        
    }
};

运行截图

在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值