玩转算法面试：（六）二叉树和递归

最新推荐文章于 2022-02-25 20:43:46 发布
最新推荐文章于 2022-02-25 20:43:46 发布
阅读量219 收藏
点赞数 1
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014376961/article/details/99615882
版权

111. 二叉树的最小深度

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

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

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

示例:

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

    3
   / \
  9  20
    /  \
   15   7

返回它的最小深度  2.

class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root == NULL)
            return 0;
        if(root->left == NULL && root->right != NULL)
        {
            return 1+minDepth(root->right);
        }
        if(root->left != NULL && root->right == NULL)
        {
            return 1+minDepth(root->left);
        }
        
        return min(minDepth(root->right), minDepth(root->left))+1;
    }
};

226. 翻转二叉树

翻转一棵二叉树。

示例：

输入：

     4
   /   \
  2     7
 / \   / \
1   3 6   9

输出：

     4
   /   \
  7     2
 / \   / \
9   6 3   1

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root == NULL)
            return root;
        
        swap(root->left, root->right);
        invertTree(root->left);
        invertTree(root->right);
        
        return root;
    }
};

非递归解法

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root == NULL)
            return root;
        
        stack<TreeNode*> Tstack;
        Tstack.push(root);
        while(!Tstack.empty())
        {
            TreeNode* p = Tstack.top();
            Tstack.pop();
            
            if(p->left || p->right)
                swap(p->left, p->right);
            if(p->left)
                Tstack.push(p->left);
            if(p->right)
                Tstack.push(p->right);
        }
        
        return root;
    }
};

100. 相同的树

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

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

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

class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if(p == NULL && q == NULL)
            return true;
        if(p == NULL || q == NULL || p->val != q->val)
            return false;
        
        return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
    }
};

101. 对称二叉树

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

例如，二叉树 [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 helper(root->left, root->right);
    }
    bool helper(TreeNode *left, TreeNode *right)
    {
        if(!left && !right)
            return true;
        else if(left && right && left->val == right->val)
            return helper(left->left, right->right) && helper(left->right, right->left);
        else
            return false;
    }
};

222. 完全二叉树的节点个数

给出一个完全二叉树，求出该树的节点个数。

说明：

完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

示例:

输入:
    1
   / \
  2   3
 / \  /
4  5 6

输出: 6

class Solution {
public:
    int countNodes(TreeNode* root) {
        int hleft = 0, hright = 0;
        TreeNode* left = root, *right = root;
        while(left)
        {
            hleft++;
            left = left->left;
        }
        while(right)
        {
            hright++;
            right = right->right;
        }
        if(hleft == hright)
            return pow(2, hleft) - 1;
        return countNodes(root->left) + countNodes(root->right) + 1;
    }
};

计算任何树的结点个数

class Solution {
public:
    int countNodes(TreeNode* root) {
        if(root == NULL)
            return 0;
        
        int left = countNodes(root->left);
        int right = countNodes(root->right);
        
        return left + right + 1;
    }
};

110. 平衡二叉树

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

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

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

class Solution {
public:
    int depth(TreeNode* root)
    {
        if(root == NULL)
            return 0;
        return max(depth(root->left), depth(root->right)) + 1;
    }
    bool isBalanced(TreeNode* root) {
        if(!root)
            return true;
        if(abs(depth(root->left) - depth(root->right)) > 1)
            return false;
        return isBalanced(root->left) && isBalanced(root->right);
    }
};
class Solution {
public:
    bool isBalanced(TreeNode* root) {
        if(checkTree(root) != -1)
            return true;
        return false;
    }
    int checkTree(TreeNode *root)
    {
        if(!root)
            return 0;
        int left = checkTree(root->left);
        int right = checkTree(root->right);
        if(abs(left - right) > 1 || left < 0 || right < 0)
            return -1;
        return max(left, right) +1;
    }
};

112. 路径总和

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

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

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

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

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

class Solution {
public:
    bool hasPathSum(TreeNode* root, int sum) {
        if(!root)
            return false;
        if(!root->left && !root->right)
            return root->val == sum ;
        return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
    }
};

404. 左叶子之和

计算给定二叉树的所有左叶子之和。

示例：

    3
   / \
  9  20
    /  \
   15   7

在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24

class Solution {
public:
    void helper(TreeNode* root, int &sum)
    {
        if(root == NULL)
            return;
        if(root->left && root->left->left == NULL && root->left->right == NULL)
            sum = sum + root->left->val;
        helper(root->left, sum);
        helper(root->right, sum);
    }
    int sumOfLeftLeaves(TreeNode* root) {
        int sum = 0;
        helper(root, sum);
        return sum;
    }
};

257. 二叉树的所有路径

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

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

示例:

输入:

   1
 /   \
2     3
 \
  5

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

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

第一种方法递归

class Solution {
public:
    void dfs(TreeNode* root, vector<string> &ret, string temp)
    {
        if(root->left == NULL & root->right == NULL)
        {
            ret.push_back(temp);
            return ;
        }
        if(root->left)
            dfs(root->left, ret, temp + "->" + to_string(root->left->val));
        if(root->right)
            dfs(root->right, ret, temp + "->" + to_string(root->right->val));
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> ret;
        
        if(root == NULL)
            return ret;
        
        dfs(root, ret, to_string(root->val));
        
        return ret;
    }
};

第二种方法DFS

class Solution {
public:
    vector<string> binaryTreePaths(TreeNode* root) {
        stack<TreeNode*> tstack;
        stack<string> path;
        vector<string> ret;
        string temp = "";
        
        if(root == NULL)
            return ret;
        tstack.push(root);
        path.push(to_string(root->val));
        while(!tstack.empty())
        {
            TreeNode* node = tstack.top();
            string temp = path.top();
            tstack.pop();
            path.pop();
            if(node->left == NULL && node->right == NULL)
            {
                ret.push_back(temp);
            }
            
            if(node->left)
            {
                tstack.push(node->left);
                path.push(temp + "->" + to_string(node->left->val));
            }
                    
            if(node->right)
            {
                path.push(temp + "->" + to_string(node->right->val));
                tstack.push(node->right);
            }
        }
        
        return ret;
    }
};

第三种方法BFS

class Solution {
public:
    vector<string> binaryTreePaths(TreeNode* root) {
        queue<TreeNode*> tqueue;
        queue<string> path;
        vector<string> ret;
        string temp = "";
        
        if(root == NULL)
            return ret;
        tqueue.push(root);
        path.push(to_string(root->val));
        while(!tqueue.empty())
        {
            TreeNode* node = tqueue.front();
            string temp = path.front();
            tqueue.pop();
            path.pop();
            if(node->left == NULL && node->right == NULL)
            {
                ret.push_back(temp);
            }
            
            if(node->left)
            {
                tqueue.push(node->left);
                path.push(temp + "->" + to_string(node->left->val));
            }
                    
            if(node->right)
            {
                path.push(temp + "->" + to_string(node->right->val));
                tqueue.push(node->right);
            }
        }
        
        return ret;
    }
};

第四种方法

class Solution {
public:
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> ret;
        
        if(root == NULL)
            return ret;
        
        if(root->left==NULL && root->right==NULL)
        {
            ret.push_back(to_string(root->val));
            return ret;
        }
        
        vector<string> left = binaryTreePaths(root->left);
        for(int i = 0; i < left.size(); i++)
        {
            ret.push_back(to_string(root->val) + "->" + left[i]);
        }
        vector<string> right = binaryTreePaths(root->right);
        for(int i = 0; i < right.size(); i++)
        {
            ret.push_back(to_string(root->val) + "->" + right[i]);
        }
        
        return ret;
    }
};

113. 路径总和 II

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

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

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

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

返回:

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

思路：分别往左子树，右子树递归遍历所有路径，每次递归就减去相应的节点值，到了叶子结点如果剩余值与叶子结点值相等，则该条路径符合要求，记录下该条路径，不符合的中间结果就pop掉。

class Solution {
public:
    void helper(TreeNode* root, int sum, vector<int> &temp, vector<vector<int>> &ret)
    {
        if(!root)
            return;
        temp.push_back(root->val);
        if(root->left == NULL && root->right == NULL && root->val == sum)
        {
            ret.push_back(temp);
        }
        
        helper(root->left, sum-root->val, temp, ret);
        helper(root->right, sum-root->val, temp, ret);
        temp.pop_back();
    }
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        vector<int> temp;
        vector<vector<int>>ret;
        helper(root, sum, temp, ret);
        return ret;
    }
};

129. 求根到叶子节点数字之和

给定一个二叉树，它的每个结点都存放一个 0-9 的数字，每条从根到叶子节点的路径都代表一个数字。

例如，从根到叶子节点路径 1->2->3 代表数字 123。

计算从根到叶子节点生成的所有数字之和。

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

示例 1:

输入: [1,2,3]
    1
   / \
  2   3
输出: 25
解释:
从根到叶子节点路径 1->2 代表数字 12.
从根到叶子节点路径 1->3 代表数字 13.
因此，数字总和 = 12 + 13 = 25.

示例 2:

输入: [4,9,0,5,1]
    4
   / \
  9   0
 / \
5   1
输出: 1026
解释:
从根到叶子节点路径 4->9->5 代表数字 495.
从根到叶子节点路径 4->9->1 代表数字 491.
从根到叶子节点路径 4->0 代表数字 40.
因此，数字总和 = 495 + 491 + 40 = 1026.

思路：分别往左子树，右子树递归遍历所有路径。到叶子节点算出数组中的值

class Solution {
public:
    void helper(TreeNode* root, vector<int> &temp, int &sum)
    {
        if(!root)
            return;
        temp.push_back(root->val);
        if(root->left == NULL && root->right == NULL)
        {
            int ret = 0;
            for(int i = 0; i < temp.size();i++)
                ret = ret*10 + temp[i];
            sum = sum + ret;
        }
        
        helper(root->left, temp, sum);
        helper(root->right, temp, sum);
        temp.pop_back();
    }
    
    int sumNumbers(TreeNode* root) {
        if(root == NULL)
            return 0;
        vector<int> temp;
        int sum = 0;
        helper(root, temp, sum);
        return sum;
    }
};

437. 路径总和 III

给定一个二叉树，它的每个结点都存放着一个整数值。

找出路径和等于给定数值的路径总数。

路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。

二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。

示例：

root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8

      10
     /  \
    5   -3
   / \    \
  3   2   11
 / \   \
3  -2   1

返回 3。和等于 8 的路径有:

1.  5 -> 3
2.  5 -> 2 -> 1
3.  -3 -> 11

class Solution {
public:
    int helper(TreeNode* node, int sum)
    {
        if(node == NULL)
            return 0;
        
        int res = 0;
        if(node->val == sum)
            res = res+1;
        res += helper(node->left, sum-node->val);
        res += helper(node->right, sum-node->val);
        
        return res;
    }
    int pathSum(TreeNode* root, int sum) {
        if(root == NULL)
            return 0;
        
        int res = helper(root, sum);//以根节点为起始点的和为sum的路径
        res += pathSum(root->left, sum);//左右子树和为sum的路径
        res += pathSum(root->right, sum);
        
        return res;
    }
};

235. 二叉搜索树的最近公共祖先

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉搜索树:  root = [6,2,8,0,4,7,9,null,null,3,5]

 

示例 1:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6
解释: 节点 2 和节点 8 的最近公共祖先是 6。

示例 2:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(!root)
            return NULL;
        
        if(root->val < p->val && root->val < q->val)
            return lowestCommonAncestor(root->right, p, q);
        if(root->val > p->val && root->val > q->val)
            return lowestCommonAncestor(root->left, p, q);
        
        return root;
    }
};
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(!root)
            return NULL;
        while(root)
        {
            if(root->val < p->val && root->val < q->val)
                root= root->right;
            else if(root->val > p->val && root->val > q->val)
                root = root->left;
            else
                return root;
        }
        return NULL;
    }
};

98. 验证二叉搜索树

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

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

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

示例 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 dfs(TreeNode *root, long min, long max)
    {
        if(!root)
            return true;
        if(root->val <= min || root->val >= max)
            return false;
        return dfs(root->left, min, root->val) && dfs(root->right, root->val, max);
    }
    bool isValidBST(TreeNode* root) {
        return dfs(root, LONG_MIN, LONG_MAX);
    }
};

第二种方法：中序遍历,采用迭代法中序遍历

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        
        stack<TreeNode*> tstack;
        long flag = LONG_MIN;
        
        while(!tstack.empty() || root != NULL)
        {
            while(root)
            {
                tstack.push(root);
                root= root->left;
            }
            
            root = tstack.top();
            tstack.pop();
            if(root->val <= flag)
                return false;
            flag = root->val;
            root = root->right;
        }
        
        return true;
    }
};

450. 删除二叉搜索树中的节点

给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。

一般来说，删除节点可分为两个步骤：

    首先找到需要删除的节点；
    如果找到了，删除它。

说明： 要求算法时间复杂度为 O(h)，h 为树的高度。

示例:

root = [5,3,6,2,4,null,7]
key = 3

    5
   / \
  3   6
 / \   \
2   4   7

给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。

一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。

    5
   / \
  4   6
 /     \
2       7

另一个正确答案是 [5,2,6,null,4,null,7]。

    5
   / \
  2   6
   \   \
    4   7

删除的节点有三种情况

  1.     删除的节点无子节点。直接删除该节点
  2.     删除的节点有且仅有一个子节点。子节点替换删除节点
  3.     删除的节点同时有两个节点。一种是从删除节点的右分支查找最小值，赋值给删除节点，再去右分支删除找到的这个最小值；另一种是从删除节点的左分支查找最大值，赋值给删除节点，再去左分支删除这个最大值。
class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if(root == NULL)
            return NULL;
        if(root->val > key)
            root->left = deleteNode(root->left, key);
        else if(root->val < key)
            root->right = deleteNode(root->right, key);
        else
        {
            if(root->left && root->right)
            {
                TreeNode * temp = root->right;
                while(temp->left)
                    temp = temp->left;
                root->val = temp->val;
                root->right = deleteNode(root->right, temp->val);
            }
            else
            {
                TreeNode *temp = root;
                if(!root->left)
                    root = root->right;
                else if(!root->right)
                    root = root->left;
                delete temp;
            }
        }
        return root;
    }
};

108. 将有序数组转换为二叉搜索树

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

本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 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) {
        return binaryBuildTree(nums, 0, nums.size()-1);
    }
    TreeNode *binaryBuildTree(vector<int> nums, int left, int right)
    {
        if(left > right)
            return NULL;
        int mid = (left + right) /2;
        TreeNode *cur = new TreeNode(nums[mid]);
        cur->left = binaryBuildTree(nums, left, mid - 1);
        cur->right = binaryBuildTree(nums, mid+1, right);
        return cur;
    }
};

230. 二叉搜索树中第K小的元素

给定一个二叉搜索树，编写一个函数 kthSmallest 来查找其中第 k 个最小的元素。

说明：
你可以假设 k 总是有效的，1 ≤ k ≤ 二叉搜索树元素个数。

示例 1:

输入: root = [3,1,4,null,2], k = 1
   3
  / \
 1   4
  \
   2
输出: 1

示例 2:

输入: root = [5,3,6,2,4,null,null,1], k = 3
       5
      / \
     3   6
    / \
   2   4
  /
 1
输出: 3

第一种方法：使用递归的方法求出左子树的节点个数，个数等于k-1就返回根节点，大于就去左子树寻找，小于就去右子树寻找。

class Solution {
public:
    int calTreeSize(TreeNode *root)
    {
        if(root == NULL)
            return 0;
        return 1 + calTreeSize(root->left) + calTreeSize(root->right);
    }
    int kthSmallest(TreeNode* root, int k) {
        if(root == NULL)
            return -1;
        int leftsize = calTreeSize(root->left);
        if(leftsize + 1 == k)
            return root->val;
        else if(leftsize >= k)
            return kthSmallest(root->left, k);
        else
            return kthSmallest(root->right, k-leftsize-1);
    }
};

第二种方法：使用中序遍历，求出第k个节点

class Solution {
public:
    int kthSmallest(TreeNode* root, int k) {
        if(root == NULL)
            return -1;
        stack<TreeNode*> ret;
        TreeNode *p = root;
      
        while(p != NULL || !ret.empty())
        {
            while(p)
            {
                ret.push(p);
                p = p->left;
            }
            p = ret.top();
            if(--k == 0)
                return p->val;
            ret.pop();
            p = p->right;
        }
        return -1;
    }
};

236. 二叉树的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉树:  root = [3,5,1,6,2,0,8,null,null,7,4]

 

示例 1:

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出: 3
解释: 节点 5 和节点 1 的最近公共祖先是节点 3。

示例 2:

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出: 5
解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。

思路：通过返回值是否为NULL来标识是否找到相应的节点
p,q在左右子树，当前的根节点就是公共的祖先节点；如果p,q同在左子树或者右子树，公共的祖先节点是p或者q

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(!root || !p || !q)
            return NULL;
        if(root == p || root == q)
            return root;
        TreeNode *parentleft = lowestCommonAncestor(root->left, p, q);
        TreeNode *parentright = lowestCommonAncestor(root->right, p, q);
        if(parentleft && parentright)
            return root;
        return parentleft ? parentleft : parentright;
    }
};
 

求二叉树中最远的两个节点的距离

求两个节点之间最远的距离：

  1. 两个节点都是叶子结点
  2. 一个是叶子结点一个是根节点

思路：

 

（1）如果具有最远距离的两个节点经过了根节点，那么最远的距离就是左边最深的深度加上右边最深的深度之和。

（2）如果具有最远距离的两个节点之间的路径不经过根节点，那么最远的距离就在根节点的其中一个子树上的两个叶子结点。

int GetFarDistance()
       {
              int distance = -1;
              _Height(_root,distance);
              return distance;
       }
protected:
       int _Height(Node* root, int& distance)
       {
              if (root == NULL)
              {
                     return 0;
              }
              int leftH = _Height(root->_left);
              int rightH = _Height(root->_right);
              if (leftH+rightH > distance)
              {
                     distance = leftH + rightH;
              }
              return leftH > rightH ? leftH+1 : rightH+1;
       }

求第k层节点的个数

int get_k_level(Node* root, int k)
{
    if(root == NULL || k <= 0)
        return 0;
    
    if(root != NULL && k == 1)
        return 1;
    
    return get_k_level(root->left, k-1) + get_k_level(root->right, k-1);
}

 

coffee-123
关注
专栏目录
玩转算法面试笔记
Meow5的博客
04-19 439
title: 玩转算法面试笔记 主要分章节记录了LeetCode的题，看题目的话可以从第二章开始 1、聊聊算法面试 1.1、对一组数据进行排序，你会怎么做呢 1、这组数据有什么样的特征? 有没有可能包含有大量重复的元素? 如果有这种可能的话，三路快排是更好地选择。(Java种快排的基本实现就是使用三路快排) 是否大部分数据距离它正确的位置很近?是否近乎有序? 如果是这样的话，插入排序是更好地选择。（如对银行的业务按照业务发生的时间进行排序，大多数业务先发生也先结束，少数处理的业务先发生但是处理.
玩转算法面试LeetCode题目目录
Biyu_csdn的博客
06-15 1093
LeetCode题目目录数组查找表相关问题在链表中穿针引线 玩转算法面试课程中提到的LeetCode的题目以及对应的连接。 ----------------------------2019-05-14更新---------------------------- 数组 283 27 26 80 75 88 215 167 125 344 345 11 209 3 43...
LeetCode 144 ——二叉树的前序遍历
weixin_33697898的博客
11-17 126
1. 题目 2. 解答 2.1. 递归法 定义一个存放树中数据的向量 data，从根节点开始，如果节点不为空，那么 将当前节点的数值加入到 data 中 递归得到其左子树的数据向量 temp，将 temp 合并到 data 中去 递归得到其右子树的数据向量 temp，将 temp 合并到 data 中去 /** * Definition for a binary t...
LeetCode 144 二叉树的前序遍历
Biu Biu Biu ~~~~~
05-18 346
给定一个二叉树，返回它的 前序 遍历。 示例:输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,2,3] 进阶: 递归算法很简单，你可以通过迭代算法完成吗？/** * Definition for a binary tree node. * public class TreeNode { * int val; * ...
【LeetCode】144. 二叉树的前序遍历 结题报告 (C++)
暮雨凉初透
10-10 122
原题地址：https://leetcode-cn.com/problems/binary-tree-preorder-traversal/description/ 题目描述； 给定一个二叉树，返回它的 前序 遍历。  示例: 输入: [1,null,2,3]      1     \      2     /    3  输出: [1,2,3] 进阶: 递归算法很简单，你可以通过迭代算法...
《树》面试题 04.12. 求和路径《leetcode》
Zyy~的博客
12-01 387
面试题 04.12. 求和路径 难度中等41 给定一棵二叉树，其中每个节点都含有一个整数数值(该值或正或负)。设计一个算法，打印节点数值总和等于某个给定值的所有路径的数量。注意，路径不一定非得从二叉树的根节点或叶节点开始或结束，但是其方向必须向下(只能从父节点指向子节点方向)。 示例: 给定如下二叉树，以及目标和sum = 22， 5 / \ 4 8 / / \ 11 .
[leetcode]给定一个二叉树，它的每个结点都存放着一个整数值
假装路过的路人甲的博客
05-25 1923
给定一个二叉树，它的每个结点都存放着一个整数值 找出路径和等于给定数值的路径总数。 路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。 二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。 示例： root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8 10 / \ 5 -3 / \ \ 3 2 11 / \
玩转算法面试 leetcode
最新发布
01-13
1 算法面试到底是什么鬼？ 2 面试中的复杂度分析 3 数组中的问题其实最常见 4 查找表相关问题 5 在链表中穿针引线 6 栈、队列、优先队列 7 二叉树和递归 8 递归和回溯法 9 动态规划基础 10 谈心算法 11 课程总结
玩转算法面试-- Leetcode真题分门别类讲解
weixin_43608645的博客
04-04 1428
如何“正确”的回答一个算法问题 对一组数据进行排序： 1、这组数据有什么样的特征？     • ①有没有可能包含有大量重复的元素？     如果有这种可能的话，三路快排是更好的选择(Java种快排的基本实现就是使用三路快排)。     • ②是否大部分数据距离它正确的位置很近？是否近乎有序？     如果是这样的话，插入排序是更好的选择（如对银行的业务按照业务发生的时间进行排序，大多数业务先发生也...
一起玩转算法面试，保姆级攻略（附高清无码算法总结导图）,建议收藏
热门推荐
启舰
06-29 1万+
本文已收录至启舰的电子书《逆天改命—程序员的成神之路》，github地址：https://github.com/harvic/FightingCoder 欢迎star。点击【阅读原文】也可直达。 我大学时候也很傻，为了校招，看了不下于五本算法书，加上LeetCode，刷了大半年。 总共一两千道题啊……不刷怕考到……忘了刷，刷了忘……毛都快掉没了…… 现在工作近十年，辗转几个大厂，由当年的应试者变成了出题人，才知道，完全不必这么辛苦。 任何事情都遵循28原则，我们只要把握住那20%，就能拿到80..
给你一个二叉树，其中每个节点都包含一个整数值。查找总和给定值的路径数，路径不需要在根或叶子处开始或结束，但必须向下
i_am_bird的博客
12-13 2095
本题源自leetcode  437 ------------------------------------------------------------- 思路：递归 用一个变量记录当前和。然后递归遍历左子树和右子树。 代码： int pathSum(TreeNode* root, int sum) { if(!root) ret
leetcode437路径总和III（给定一个二叉树，它的每个结点都存放着一个整数值。 找出路径和等于给定数值的路径总数）
Miriwas
08-22 1049
  给定一个二叉树，它的每个结点都存放着一个整数值。找出路径和等于给定数值的路径总数。   路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。   二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。 示例： root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8 返回 3。和等于 8 的路径有: 5 -> 3 5 -> 2 -> 1 -3 -> 1
二叉树相关算法题总结
weixin_43691723的博客
08-28 1129
本文为博主刷到的二叉树相关算法题的总结。
给定一个整数 n,生成所有由 1...n 为节点组成的不同的二叉查找树。
wm12345645的博客
08-21 3571
题目解析：给定一个n，用1-n这些数字去创建搜索二叉树，并将所有搜索二叉树的头结点放到vector中返回。 解题思路：好吧，这题我也说不清是怎么肥事，自己举个例子画一画就明白了。 class Solution { public: vector&lt;TreeNode *&gt; generateTrees(int n) { /*vector&lt;TreeNode*&gt; res...
【2021复旦机考】三题
jiangliming123的博客
02-25 1082
2021年真题 第一题 题目描述：给定一颗二叉树，树的每个节点的值为一个正整数。如果从根节点到节点 N 的路径上不存在比节点 N 的值大的节点，那么节点 N 被认为是树上的关键节点。求树上所有的关键节点的个数。请写出程序，并解释解题思路。 例子： 输入：3, 1, 4, 3, null, 1, 5 输出：4（图中蓝色节点是关键节点） #include<iostream> #include<vector> using namespace std; int main(){ ..
8·假设二叉树采用二叉链表存储结构存储,试设计一个算法,计算一棵给定二叉树的所有 双分支结点个数。
Anthony_4926
07-28 1万+
8·假设二叉树采用二叉链表存储结构存储,试设计一个算法,计算一棵给定二叉树的所有双分支结点个数。 思路：任何一种遍历都行，判断左右指针都非空的节点的个数。 int n = 0; void f(TreeNode *root){ if(root){ if(root->left && root->right) n++; f(root->left); f(root->right); } } ...
LeetCode刷题总结之二叉树的构建算法-一道题13种解法
weixin_47067712的博客
05-24 737
前言 最近开始刷到一些二叉树的构建的算法题，挺有意思的，打算总结一下。这里总结的都是确定二叉树的构造算法题，可能有多个构造结果的算法题就没考虑。 从构造目标上来看，这里讨论的算法题可以分为两种： 二叉树的构造 二叉搜索树（BST）的构造 从构造条件上来看，这里讨论的算法题也可以分为两种： 不含重复数值节点的二叉树的构造 含重复数值节点的二叉树的构造 1.从前序与中序遍历以及中序和后序遍历构造二叉树 这2个题目分别为： LeetCode.105 从前序与中序遍历序列构造二叉树，中等难度 LeetCo
算法(5)-暴力搜索-排列、组合(子序列、子数组、子串、回文)
sinat_40624829的博客
05-13 332
base - 重复子问题、状态转移// 509. 斐波那契数 -- 重复子问题 f(20) = f(19) + f(18) , f(19)拆解又需要重新解f(18), 用memo/dp数组来记住字问题的解，需要求解一个子问题时，先去看看适否以及有人解过了。// 自顶向下(递归返回)、自低向上(循环迭代)、空间约简(只记录前两个状态)// 322. 零钱兑换 -- 状态转移-暴力递归(自顶向下)， for循环（自底向上）
Leetcode算法题之二叉树模板
weixin_43692357的博客
08-02 425
一、树的定义 Definition for a binary tree node. class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right 二、树的遍历 1、前序遍历 思路： 从根节点开始，每次迭代弹出当前栈顶元素，并将其孩子节点压入栈中，先压右孩子再压左孩子.
二叉树遍历算法详解：递归与非递归实现
"二叉树遍历C语言(递归-非递归)六种算法" 二叉树遍历是数据结构中一个重要的概念，它主要用于遍历或搜索二叉树的所有节点。在这个文档中，作者详细介绍了使用C语言实现二叉树的先序、中序和后序遍历的递归和非递归...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值