LeetCode C++刷题106-110题题解

目录

 

106 从中序与后续遍历构建二叉树

题目

题解

完整代码

107 二叉树的层次遍历II

题目

题解

完整代码

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

题目

题解

完整代码

109 有序链表转换二叉搜索树

题目

题解

完整代码

110 平衡二叉树

题目

题解

完整代码

---

106 从中序与后续遍历构建二叉树

题目

根据一棵树的中序遍历与后序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

例如，给出

中序遍历 inorder = [9,3,15,20,7]
后序遍历 postorder = [9,15,7,20,3]
返回如下的二叉树：

    3
   / \
  9  20
    /  \
   15   7

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题解

递归

完整代码

/**
 * 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 {
private:
    map idx;
public:
    TreeNode* buildTreeImp(vector& inorder, vector& postorder, int leftPost, 
                           int rightPost, int leftIn, int rightIn) 
    {
        if(leftPost < rightPost) {
            return nullptr;
        }
        int rootIdx = leftPost;
        int inIdx = idx[postorder[rootIdx]];
        TreeNode* root = new TreeNode(postorder[rootIdx]);
        int length = rightIn - inIdx;
        root->left = buildTreeImp(inorder, postorder, leftPost - length - 1, rightPost, leftIn, inIdx - 1);
        root->right = buildTreeImp(inorder, postorder, leftPost - 1,  leftPost - length, inIdx + 1, rightIn);
        return root;
    }

    TreeNode* buildTree(vector& inorder, vector& postorder) {
        int n = inorder.size();
        for(int i = 0; i < n; ++i) {
            idx[inorder[i]] = i;
        }
        return buildTreeImp(inorder, postorder, n - 1, 0, 0, n- 1);
    }
};

107 二叉树的层次遍历II

题目

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

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

    3
   / \
  9  20
    /  \
   15   7
返回其自底向上的层次遍历为：

[
  [15,7],
  [9,20],
  [3]
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题解

迭代

完整代码

/**
 * 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> levelOrderBottom(TreeNode* root) {
        if(root == nullptr) {
            return {};
        }
        queue s;
        s.push(root);
        vector> result;

        while(!s.empty()) {
            int n = s.size();
            vector tmp;
            for(int i = 0; i < n; i++) {
                TreeNode* node = s.front();
                s.pop();
                tmp.push_back(node->val);
                if(node->left != nullptr) {
                    s.push(node->left);
                }
                if(node->right != nullptr) {
                    s.push(node->right);
                }
            }     
            result.insert(result.begin(), tmp);
        }

        return result;
    }
};

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

题目

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

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

示例:

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

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

      0
     / \
   -3   9
   /   /
 -10  5

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题解

递归

完整代码

/**
 * 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:
    // 递归
    TreeNode* sortedArrayToBSTImp(vector& nums, int l, int r) 
    {
        if(l > r) {
            return nullptr;
        }

        int mid = (l + r + 1) / 2;
        TreeNode* root = new TreeNode(nums[mid]);
        root->left = sortedArrayToBSTImp(nums, l, mid - 1);
        root->right = sortedArrayToBSTImp(nums, mid + 1, r);
        return root;
    }

    TreeNode* sortedArrayToBST(vector& nums) 
    {
        int n = nums.size();
        if(n == 0) {
            return nullptr;
        }
        
        return sortedArrayToBSTImp(nums, 0, n - 1);
    }
};

109 有序链表转换二叉搜索树

题目

给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。

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

示例:

给定的有序链表： [-10, -3, 0, 5, 9],

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

      0
     / \
   -3   9
   /   /
 -10  5

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/convert-sorted-list-to-binary-search-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题解

快慢指针+递归

完整代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
/**
 * 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:
    /*
    快慢指针:
        快指针每次走两步，慢指针每次走一步
        当快指针到达最后一个节点时，慢指针刚好到中间节点
    */
    TreeNode* helper(ListNode* l, ListNode* r)
    {
        if(l == r) {
            return nullptr;
        }
        ListNode* slow = l;
        ListNode* fast = l;
        while(fast != r && fast->next != r) {
            slow = slow->next;
            fast = fast->next;
            fast = fast->next;
        }
        TreeNode* root = new TreeNode(slow->val);
        root->left = helper(l, slow);
        root->right = helper(slow->next, r);
        return root;
    }

    TreeNode* sortedListToBST(ListNode* head) 
    {
        if(head == nullptr) {
            return nullptr;
        }

        return helper(head, nullptr);
    }
};

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 。

 

题解

递归

完整代码

/**
 * 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 helper(TreeNode* root)
    {
        if(root == nullptr) {
            return 0;
        }
        return max(helper(root->left), helper(root->right)) + 1;
    }

    bool isBalanced(TreeNode* root) {
        if(root == nullptr) {
            return true;
        }
        return (abs(helper(root->left) - helper(root->right)) <= 1) && isBalanced(root->left) && isBalanced(root->right);
    }
};