二叉树系列题目

Posted ~千里之行，始于足下~

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了二叉树系列题目相关的知识，希望对你有一定的参考价值。

  1. 单值二叉树
    如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树。
    只有给定的树是单值二叉树时，才返回 true；否则返回 false。
    示例 1：
    输入：[1,1,1,1,1,null,1]
    输出：true
    示例 2：
    输入：[2,2,2,5,2]
    输出：false

链接

/**
 * 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 isUnivalTreeHelp(TreeNode * root, int val)
    
        if (!root)
           return true;
        return root->val == val && 
        isUnivalTreeHelp(root->left, val) &&
        isUnivalTreeHelp(root->right, val);
    
    bool isUnivalTree(TreeNode* root) 
        if (!(root->left) && !(root->right))
            return true;
        int value = root->val;
        return isUnivalTreeHelp(root, value);
    
;
  1. 二叉树的最大深度
    给定一个二叉树，找出其最大深度。
    二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
    说明: 叶子节点是指没有子节点的节点。
    示例：
    给定二叉树 [3,9,20,null,null,15,7]，
    3
    /
    9 20
    /
    15 7
    返回它的最大深度 3 。
    链接
/**
 * 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)
          return 0;
        if (!(root->left) && !(root->right))
          return 1;
        return 1 + max(maxDepth(root->left), maxDepth(root->right));

    
;
  1. 翻转二叉树
    翻转一棵二叉树。
    示例：
/**
 * 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 invertTreeHeaper(TreeNode * root)
    
        if (!root)  //必须有
           return;
        if (!(root->left) && !(root->right))
           return;
        //处理根
        TreeNode * tmp = root->left;
        root->left = root->right;
        root->right = tmp;
        invertTreeHeaper(root->left);
        invertTreeHeaper(root->right);

    

    TreeNode* invertTree(TreeNode* root) 
        if (!root)
           return NULL;
        if (!(root->left) && !(root->right))
           return root;
        invertTreeHeaper(root);
        return root;
    
;
  1. 相同的树
    给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。
    如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。


链接

/**
 * 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 && !q)
            return true;
        if (!p || !q)
            return false;
        return  p->val == q->val &&
        isSameTree(p->left, q->left)&&
        isSameTree(p->right, q->right);
    
;
  1. 对称二叉树
    给定一个二叉树，检查它是否是镜像对称的。

    链接
/**
 * 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 isSymmetricHelper(TreeNode * root1, TreeNode * root2)
    
        if (!root1 && !root2)
            return true;
        if (!root1 || !root2)
            return false;
        return root1->val == root2->val &&
               isSymmetricHelper(root1->left, root2->right)&&
               isSymmetricHelper(root1->right, root2->left);
    
    bool isSymmetric(TreeNode* root) 
        if (!root)
           return true;
        if (!(root->left) && !(root->right))
           return true;
        TreeNode * tmp = root;
        return isSymmetricHelper(root, tmp);
    
;
  1. 二叉树的前序遍历
    链接
/**
 * 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 preorderTraversalHeaper(TreeNode * root, vector<int> & res)
    
        if (!root)
           return ;
        res.push_back(root->val);
        preorderTraversalHeaper(root->left, res);
        preorderTraversalHeaper(root->right, res);
    
    vector<int> preorderTraversal(TreeNode* root) 
        if (!root)
           return ;
        vector<int> res;
        preorderTraversalHeaper(root, res);
        return res;
    
;
  1. 二叉树的中序遍历
    给定一个二叉树的根节点 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:
    void inorderTraversalHeaper(TreeNode * root, vector<int> & res)
    
        if (!root)
           return;
        inorderTraversalHeaper(root->left, res);
        res.push_back(root->val);
        inorderTraversalHeaper(root->right, res);
    
    vector<int> inorderTraversal(TreeNode* root) 
        if (!root)
           return ;
        vector<int> res;
        inorderTraversalHeaper(root, res);
        return res;

    
;
  1. 二叉树的后序遍历
    链接
/**
 * 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 postorderTraversalHelper(TreeNode * root, vector<int> & res)
    
        if (!root)
           return;
        postorderTraversalHelper(root->left, res);
        postorderTraversalHelper(root->right, res);
        res.push_back(root->val);
    
    vector<int> postorderTraversal(TreeNode* root) 
        if (!root)
           return ;
        vector<int> res;
        postorderTraversalHelper(root, res);
        return res;
    
;
  1. 二叉树的层序遍历
    给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。
    示例：
    二叉树：[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;
 *     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) 
        if (!root)
           return ;
        queue<TreeNode*> qu;
        vector< vector<int> > result;
        qu.push(root);
        while (!qu.empty())
        
            vector<int> v;
            int size = qu.size();
            for (int i = 0; i < size; i++)
            
                TreeNode * node = qu.front();
                v.push_back(node->val);
                qu.pop();
                if (node->left)
                   qu.push(node->left);
                if (node->right)
                   qu.push(node->right);
            
            result.push_back(v);
        
        return result;
    
;


链接

/**
 * 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 levelOrderHelp(TreeNode * root, vector< vector<int> > & res)
    
        bool flag = false;
        queue<TreeNode*> q;
        q.push(root);

        while (!q.empty())
        
            int size = q.size();
            vector<int> v(size);
            for (int i = 0; i < size; i++)
            
                TreeNode * tmp = q.front();
                q.pop();
                //奇数从左往右 偶数从右往左
                v[flag ? size-1-i: i] = tmp->val;

                if (tmp->left)
                
                    q.push(tmp->left);
                
                if (tmp->right)
                
                    q.push(tmp->right);
                
            
            flag = !flag;
            res.push_back(v);
            v.clear();
            
        
    

    vector<vector<int>> levelOrder(TreeNode* root) 
        vector< vector<int> > res;
        if (!root)
           return ;
        levelOrderHelp(root, res);
        return res;
    
;
  1. 另一棵树的子树
    给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。
    二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

    链接
/**
 * 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 isSameStructure(TreeNode * root1, TreeNode * root2)
    
        if (!root1 && !root2)
           return true;
        if (!root1 || !root2)
           return false;
        return root1->val == root2->val &&
               isSameStructure(root1->left, root2->left)&&
               isSameStructure(root1->right, root2->right);
    
    bool isSubtreeHelper(TreeNode * root, TreeNode * subRoot)
    
        if (!root)
           return false;
        return isSameStructure(root, subRoot) ||
        isSubtreeHelper(root->left, subRoot) ||
        isSubtreeHelper(root->right, subRoot);
    
    bool isSubtree(TreeNode* root, TreeNode* subRoot) 
        return isSubtreeHelper(root, subRoot);
    
;


链接
注: 树的子树和子结构不一样

这种即为子结构.

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

typedef struct TreeNode TreeNode;
bool isSameStructure(TreeNode * root1, TreeNode * root2)

        if (!root2)
           return true;
        if (!root1)
           return false;
        return root1->val == root2->val &&
               isSameStructure(root1->left, root2->left)&&
               isSameStructure(root1->right, root2->right);


bool isSubStructureHelper(struct TreeNode* root, struct TreeNode* subRoot)
        if (!root)
           return false;
        return isSameStructure(root, subRoot) ||
        isSubStructureHelper(root->left, subRoot) ||
        isSubStructureHelper(root->right, subRoot);

bool isSubStructure(TreeNode * root, TreeNode * subRoot)

    if (!subRoot)
       return false;
    return isSubStructureHelper(root, subRoot);

KY11 二叉树遍历
编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串： ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。
输入描述：
输入包括1行字符串，长度不超过100。
输出描述：
可能有多组测试数据，对于每组数据， 输出将输入字符串建立二叉树后中序遍历的序列，每个字符后面都有一个空格。 每个输出结果占一行。
示例1
输入：
abc##de#g##f###
复制
输出：
c b e g d f a
链接

#include<stdio.h>
#include<malloc.h>
#include<assert.h>
#include<string.h>

typedef struct Node

    char ch;
    struct Node * left;
    struct Node * right;
Node;

Node * BuyOneNode()

    Node * node = (Node *)malloc(sizeof(Node));
    if (!node)
    
        assert(0);
        return NULL;
    
    node->left = node->right = NULL;
    return node;


void InOrderTraver(Node * root)

    if (!root)
        return;
    InOrderTraver(root->left);
    printf("%c ", root->ch);
    InOrderTraver(root->right);


Node * CreateBitNode(char str[], int *index,int len, char invalid)

    if (*index < len && str[*index] != invalid)
    
        Node * root = BuyOneNode();
        root->ch = str[*index];
        *index += 1;
        root->left = CreateBitNode(str, index, len, invalid);
        *index += 1;
        root->right = CreateBitNode(str, index, len, invalid);
        return root;
    
    return NULL;


void DestroyBitNode(Node ** root)

    if (!(*root))
        return;
    DestroyBitNode(&(*root)->left);
    以上是关于二叉树系列题目的主要内容，如果未能解决你的问题，请参考以下文章
 

 二叉树系列题目


 剑指offer系列43---判断平衡二叉树


 算法系列——二叉树深度


 算法系列——二叉树深度


 算法系列——二叉树深度


 写写代码系列028：二叉树的深度优先遍历