代碼實現

#include <stdio.h>
#include <malloc.h>
#include <string.h>

struct Node
{
    int sum;
    int pos;
};
//返回值：0 - node1>node2，1 - node1<node2
int cmp(struct Node *node1, struct Node *node2)
{
    if(node1->sum == node2->sum)
    {
        return node1->pos < node2->pos;
    }
    return node1->sum < node2->sum;
}
//快速排序算法
void Qsort(struct Node *node, int bgn, int end, int (*ptr)(struct Node *, struct Node *))
{
    struct Node baseN;
    int left = bgn;
    int right = end;

    //對基準點賦值
    baseN.sum = node[bgn].sum;
    baseN.pos = node[bgn].pos;

    //遞歸結束
    if(bgn >= end)
    {
        return;
    }

    while(left < right)
    {
        while((left < right) && (ptr(&node[right], &baseN) == 0))
        {
            right --;
        }
        //發現小于baseN的點，放到左邊
        if(left < right)
        {
            memcpy(&node[left], &node[right], sizeof(struct Node));
            left++;
        }

        while((left < right) && (ptr(&node[left], &baseN) == 1))
        {
            left++;
        }
        //發現大于baseN的點，放到右邊
        if(left < right)
        {
            memcpy(&node[right], &node[left], sizeof(struct Node));
            right--;
        }
    }
    //將基準點放到相遇點
    memcpy(&node[left], &baseN, sizeof(struct Node));

    //對左邊遞歸
    Qsort(node, bgn, left-1, ptr);
    //對右邊遞歸
    Qsort(node, left+1, end, ptr);
}
int minseqpstsum(int *arr, int len)
{
    /***
    //下面這種網上廣為流傳的做法有嚴重的bug：如果前面的序列是遞增的，后面的則都是負數，會觸發bug
    //如：4 5 6 -1 -2
    int minsum = 0xFFFF;
    int tmpsum = 0;
    int i = 0;
    for(i = 0; i < len; i++)
    {
        tmpsum += arr[i];
        if((tmpsum <= minsum) && (tmpsum > 0))
        {
            minsum = tmpsum;
        }
        if(tmpsum > minsum)
        {
            tmpsum = 0;
        }
    }
    ***/

    struct Node node[50005];
    int i = 0;
    //minsum存放最終結果
    int minsum = -1;
    int tempsum = 0;
    int flag = 0;

    node[0].sum = 0;
    node[0].pos = 0;

    //將值賦到每個節點中
    for(i = 0; i < len; i++)
    {
        tempsum = tempsum + arr[i];
        node[i+1].sum = tempsum;
        node[i+1].pos = i+1;
    }
    //快排
    Qsort(node, 0, len, cmp);

    //獲取到最小正子序列和
    for(i = 1; i <= len; i++)
    {
        if((node[i].sum > node[i-1].sum) && (node[i].pos > node[i-1].pos))
        {
            //如果是第一次，則賦初始值
            if(flag == 0)
            {
                flag = 1;
                minsum = node[i].sum - node[i-1].sum;
            }
            else
            {
                if(node[i].sum -node[i-1].sum < minsum)
                {
                    minsum = node[i].sum - node[i-1].sum;
                }
            }
        }
    }
    return minsum;
}
int main(int argc, char *argv[])
{
    int *arr = NULL;
    int len = 0;
    int i = 0;
    int minsum = 0;

    printf("輸入數組長度：");
    scanf("%d", &len);
    arr = (int *)malloc(sizeof(int) * len);
    printf("輸入數組元素：");
    for(i = 0; i < len; i++)
    {
        scanf("%d", &arr[i]);
    }

    minsum = minseqpstsum(arr, len);
    printf("最小的正子序列和 = [%d]\n", minsum);

    free(arr);
    return 0;
}

編譯

gcc -o minpossum minpossum.c -g

測試案例

4, 0, 4, -1, -1
4,-1,6,-2,-1,3,6,-2

運行截圖

運行結果.png

參考案例

這個里面有詳細的原理

2019年6月9日