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

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

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

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

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

　　 3
   / \
  9  20
    /  \
   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:

输入:

　  5
   / \
  1   4
     / \
    3   6

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

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        if(!root)   return true;
        vector res;
        inorder(root,res);
        for(int i=1;i= res[i])
                return false;
        return true;
    }
    
    void inorder(TreeNode* root,vector& 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
 / \ / \
3  4 4  3

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

    1
   / \
  2   2
   \   \
   3    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

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

class Solution {
public:
    vector> levelOrder(TreeNode* root) {
        vector> res;
        if(!root)   return res;
        queue sameLevel;
        vector row;
        sameLevel.push(root);
        while(!sameLevel.empty())
        {
            int size = sameLevel.size();
            for(int i=0;ival);
                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& nums) {
        if(nums.empty())
            return nullptr;
        TreeNode* root = new TreeNode(nums[nums.size()/2]);
        vector vec_l = vector(nums.begin(),nums.begin()+nums.size()/2);
        vector vec_r = vector(nums.begin()+nums.size()/2+1,nums.end());
        root->left = sortedArrayToBST(vec_l);
        root->right = sortedArrayToBST(vec_r);
        return root;
    }
};