C++ Leetcode初级算法之二叉树篇

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

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

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

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

返回它的最大深度 3 。

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(!root)
            return 0;
        if(!root->right && !root->left)
            return 1;
        int leftD = 1;
        int rightD = 1;
        if(root->left)
            leftD = maxDepth(root->left);
        if(root->right)
            rightD = maxDepth(root->right);
        return 1+max(leftD,rightD);
    }
};

2.验证二叉搜索树
给定一个二叉树，判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征：

节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
示例 1:

输入:

 　 2
   / \
  1   3

输出: true
示例 2:

输入:

输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
根节点的值为 5 ，但是其右子节点值为 4 。

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        if(!root)   return true;
        vector<int> res;
        inorder(root,res);
        for(int i=1;i<res.size();i++)
            if(res[i-1] >= res[i])
                return false;
        return true;
    }
    
    void inorder(TreeNode* root,vector<int>& res)
    {
        if(!root) return;
        inorder(root->left,res);
        res.push_back(root->val);
        inorder(root->right,res);       
    }
};

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

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

说明:

如果你可以运用递归和迭代两种方法解决这个问题，会很加分。

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(!root)   return true;
        return duichen(root->left,root->right);
    }
    bool duichen(TreeNode* leftnode,TreeNode* rightnode)
    {
        if(!leftnode && !rightnode)
            return true;
        if(leftnode && rightnode && leftnode->val == rightnode->val)
            return duichen(leftnode->left,rightnode->right) && duichen(leftnode->right,rightnode->left);
        return false;
    }
};

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

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

返回其层次遍历结果：
[
[3],
[9,20],
[15,7]
]

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(!root)   return res;
        queue<TreeNode*> sameLevel;
        vector<int> row;
        sameLevel.push(root);
        while(!sameLevel.empty())
        {
            int size = sameLevel.size();
            for(int i=0;i<size;i++)
            {
                TreeNode* cur = sameLevel.front();
                row.push_back(cur->val);
                sameLevel.pop();
                if(cur->left)
                    sameLevel.push(cur->left);
                if(cur->right)
                    sameLevel.push(cur->right);
            }
            res.push_back(row);
            row.clear();
        }
        return res;
    }
};

5.将有序数组转换为二叉搜索树
将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1。

示例:

给定有序数组: [-10,-3,0,5,9],

一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树：

      0
     / \
   -3   9
   /   /
 -10  5
class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        if(nums.empty())
            return nullptr;
        TreeNode* root = new TreeNode(nums[nums.size()/2]);
        vector<int> vec_l = vector<int>(nums.begin(),nums.begin()+nums.size()/2);
        vector<int> vec_r = vector<int>(nums.begin()+nums.size()/2+1,nums.end());
        root->left = sortedArrayToBST(vec_l);
        root->right = sortedArrayToBST(vec_r);
        return root;
    }
};

C++ Leetcode初级算法之二叉树篇

猜你喜欢