LeetCode 树相关题目

面试题55 - II. 平衡二叉树

输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过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 depth(TreeNode* root, int deep)
    {
        if (!root) return deep-1;
        return max(depth(root->left, deep + 1), depth(root->right, deep + 1));
    }

    bool isBalanced(TreeNode* root) {
        if (!root) return true;
        if (abs(depth(root->left, 1) - depth(root->right, 1)) > 1) return false;
        return isBalanced(root->left) && isBalanced(root->right);
    }
};

面试题55 - I. 二叉树的深度

输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。

/**
 * 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 deep=1;
    void dfs(TreeNode* t,int depth)
    {
        if(!t) return;
        if (depth>deep) deep=depth;
        dfs(t->left,depth+1);
        dfs(t->right,depth+1);
    }
    int maxDepth(TreeNode* root) {
        if(!root)return 0;
        dfs(root->left,2);
        dfs(root->right,2);
        return deep;
        
    }
};

面试题34. 二叉树中和为某一值的路径

输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。

思路：深搜，可以用前序遍历的非递归方法。每次先找左子树，再右子树。但是要标注一下右子树是否走过，想到了后序遍历非递归方法中的pre指针，专门指示是否走过这个右子树。

/**
 * 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>> pathSum(TreeNode* root, int sum) {
          vector<vector<int>> ans;
          vector<int> tem;
          stack<TreeNode*> s;
          TreeNode* pre = NULL;
          int num = 0;
          while (root || !s.empty())
          {
              while (root)
              {
                  s.push(root);
                  num += root->val;
                  tem.push_back(root->val);
                  root = root->left;
              }
              root = s.top();
              if (!root->right && !root->left)
              {
                  if (num == sum)
                  {
                      ans.push_back(tem);
                  }
                  num -= root->val;
                  tem.pop_back();
                  s.pop();
                  pre = root;
                  root = NULL;
              }
              else if (root->right != pre)
              {
                  root = root->right;
                  pre = root;
              }
              else
              {
                  num -= root->val;
                  tem.pop_back();
                  pre = root;
                  root = NULL;
                  
                  s.pop();
              }

          }
          return ans;
      }
  };

687. 最长同值路径

给定一个二叉树，找到最长的路径，这个路径中的每个节点具有相同值。 这条路径可以经过也可以不经过根节点。

注意：两个节点之间的路径长度由它们之间的边数表示。

思路：递归即可，注意每次返回的是两个左右子树函数值的最大值，而不是和。但是最长长度则需要他们的和去判断。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def longestUnivaluePath(self, root):
        self.zuichang=0
        def longest(root,father):
            if not root:
                return 0
            left=longest(root.left,root.val)
            right=longest(root.right,root.val)
            if right+left>self.zuichang:
                self.zuichang=right+left
            ans=max(left,right)
            if root.val==father:
                ans+=1
                return ans
            else:
                return 0
        if not root:
            return 0
        left=longest(root.left,root.val)
        right=longest(root.right,root.val)
        ans=left+right
        if ans>self.zuichang:
            self.zuichang=ans
        return self.zuichang

/**
 * 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 ans = 0;
    int longest(TreeNode* root, int father)
    {
        if (!root) return 0;
        int left = longest(root->left, root->val);
        int right = longest(root->right, root->val);
        if (left + right > ans) ans = left + right;
        if (root->val == father) return max(left, right) + 1;
        else return 0;
    }
    int longestUnivaluePath(TreeNode* root) {
        if (!root) return 0;
        int left = longest(root->left, root->val);
        int right = longest(root->right, root->val);
        if (left + right > ans) ans = left + right;
        return ans;
    }
};