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);    }};