leetcode第八周解题总结

108. Convert Sorted Array to Binary Search Tree

Given an array where elements are sorted in ascending order, convert it to a height balanced BST.

题意解析：
将排序后的数组转换为一棵平衡二叉树

解题思路：
平衡二叉树的子树高度之差小于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:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        int len = nums.size();
        if(len == 0) return NULL;
        if(len == 1) return new TreeNode(nums[0]);
        return sortedArrayToBST(nums, 0, len - 1);
    }
    TreeNode* sortedArrayToBST(vector<int>& nums, int start, int end) {
        if(start > end) return NULL;
        int m = (start + end) /2;
        TreeNode* root = new TreeNode(nums[m]);
        root->left = sortedArrayToBST(nums, start, m - 1);
        root->right = sortedArrayToBST(nums, m + 1, end);
        return root;
    }
};

109. Convert Sorted List to Binary Search Tree

Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.

题意解析：
将排序后的链表转换为一棵平衡二叉树

解题思路：
与上题的要求一致，但是数组变为链表，不能索引到中间值，如果每次寻找中间节点，则时间复杂度比较大，因此需要改变思路。这里考虑到，链表的排序等于对树进行中序遍历，因此在构建树结构时，先递归右子树，再访问根节点，最后递归左子树，这样就按照链表排序进行赋值，无需更多的操作，时间复杂度O(n)。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
/**
 * 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* sortedListToBST(ListNode* head) {
        if(head == NULL) return NULL;
        int len = 0;
        lhead = head;
        ListNode* temp = head;
        while(temp != NULL){
            len ++;
            temp = temp->next;
        }
        return sortedListToBST(0, len - 1);

    }
    TreeNode* sortedListToBST(int start, int end) {
        if(start > end) return NULL;
        int mid = (start + end)/2;
        TreeNode* root = new TreeNode(-1);
        root->left = sortedListToBST(start, mid - 1);
        root->val = lhead ->val;
        lhead  = lhead ->next;
        root->right = sortedListToBST(mid + 1, end);
        return root;
    }
private:
    ListNode* lhead;
};

124. Binary Tree Maximum Path Sum

Given a binary tree, find the maximum path sum.
For this problem, a path is defined as any sequence of nodes from some starting node to any node in the tree along the parent-child connections. The path must contain at least one node and does not need to go through the root.
For example:
Given the below binary tree,

   1
  / \
 2   3

Return 6.

题意解析：
计算一棵树中的最大路径和。

解题思路：
考虑到该路径只需要包括一个节点而且不需要经过根节点的条件，不能简单的进行搜索。首先思考到，对每个子树计算最大路径，然后取最大值。因此，对于每个子树，要计算两个值:一个是通过该子树的根节点的最大路径和，另外一个是通过该子树的根节点的单边路径最大和，这个用于计算上一层的最大路径和。

/**
 * 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 = INT_MIN;
    int maxPathSum(TreeNode* root) {
        if(root == NULL) return 0;
        findMaxPath(root);
        return ans;
    }
    int findMaxPath(TreeNode* root) {
        if(root == NULL) return 0;
        int rightPath = max(findMaxPath(root->right),0);
        int leftPath = max(findMaxPath(root->left),0);
        ans = max(root->val + rightPath + leftPath, ans);

        return max(max(root->val + rightPath, root->val+ leftPath), root->val);
    }
};