1.最大连续子数组
思路比较固定,时间复杂度O(nlogn) T(n) = 2T(n/2) + O(n)。
int divide_max_sub_array(int a[],int low,int high)
{
int sum;
if (low == high) //定义终止条件
{
sum = a[low];
}
else
{
int mid = low + (high - low)/2;
int left_sum = divide_max_sub_array(a,low,mid);
int right_sum = divide_max_sub_array(a,mid+1,high);
//mid向左
int cross_left_sum = numeric_limits<int>::min();
int tmp_left_sum = 0;
for(int i = mid; i >= low; i--)
{
tmp_left_sum += a[i];
if (tmp_left_sum > cross_left_sum)
cross_left_sum = tmp_left_sum;
}
//mid向右
int cross_right_sum = numeric_limits<int>::min();
int tmp_right_sum = 0;
for(int j = mid+1; j <= high; j++)
{
tmp_right_sum += a[j];
if (tmp_right_sum > cross_right_sum)
cross_right_sum = tmp_right_sum;
}
int cross_sum = cross_left_sum + cross_right_sum;
//从left_sum、right_sum、cross_sum中选取最大的
if (left_sum >= cross_sum && left_sum >= right_sum)
sum = left_sum;
else if(right_sum >= left_sum && right_sum >= cross_sum)
sum = right_sum;
else
sum = cross_sum;
}
return sum;
}
2.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.
Solution:
分治法,自顶向下,时间复杂度O(n^2),空间复杂度O(logn)
TreeNode* sortedListToBST(ListNode* head)
{
return sortedListToBSTCore(head,listLength(head));
}
TreeNode* sortedListToBSTCore(ListNode* head, int len)
{
if(len == 0)
return NULL;
if(len == 1)
return new TreeNode(head->val);
TreeNode* root = new TreeNode(nthNode(head,len/2+1)->val);
root->left = sortedListToBSTCore(head,len/2);
root->right = sortedListToBSTCore(nthNode(head, len/2+2), (len-1)/2);
return root;
}
int listLength(ListNode* node)
{
int n = 0;
while (node)
{
n++;
node = node->next;
}
return n;
}
ListNode* nthNode(ListNode* node, int n)
{
while (--n)
node = node->next;
return node;
}