分治法专题

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