数据结构Day10

1、买卖股票的最佳时机

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。

示例 1:

输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。
示例 2:
输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

#define INT_MAX 2147483647
#define MAX(a, b)   (a>b) ? a : b
#define MIN(a, b)   (a>b) ? b : a

int maxProfit(int* prices, int pricesSize){
    int i, maxtemp=0, mintemp=INT_MAX;
    for(i=0;i<pricesSize;i++)
    {
        maxtemp = MAX(prices[i]-mintemp, maxtemp);
        mintemp = MIN(prices[i], mintemp);
    }
    return (maxtemp > 0) ? maxtemp : 0;
}

总结：这个题目中运用了滑动窗口的思想，在题解中有提到动态规划的问题，但是动态规划还没有学习，因此只是按照自己的想法实现了函数，即要想求两个值差值最大的情况，则依次判断当前的值减去之前最小的值，和之前已经存好的最大的值相比是不是最大的。当然，需要判断在判断之后更新当前最小的值。最后判断题目中的如果没有最大利润则返回0。

2、将数组分成和相等的三个部分

给你一个整数数组 A，只有可以将其划分为三个和相等的非空部分时才返回 true，否则返回 false。 形式上，如果可以找出索引 i+1 < j 且满足 (A[0] + A[1] + … + A[i] == A[i+1] + A[i+2] + … + A[j-1] == A[j] + A[j-1] + … + A[A.length - 1]) 就可以将数组三等分。

示例 1：

输出：[0,2,1,-6,6,-7,9,1,2,0,1]
’输出：true
解释：0 + 2 + 1 = -6 + 6 - 7 + 9 + 1 = 2 + 0 + 1

示例 2：
输入：[0,2,1,-6,6,7,9,-1,2,0,1]
输出：false

示例 3：
输入：[3,3,6,5,-2,2,5,1,-9,4]
输出：true
解释：3 + 3 = 6 = 5 - 2 + 2 + 5 + 1 - 9 + 4

提示：
3 <= A.length <= 50000
-10^4 <= A[i] <= 10^4

bool canThreePartsEqualSum(int* A, int ASize){
    int count = 0, i=0;
    int Ave=0, Sum = 0;
    while(count < ASize)
    {
        Sum += A[count];
        count++;
    }
    Ave = Sum / 3;
    
    if(Ave*3 != Sum)    return false;
    count = 0;
    Sum = 0;
    while(count < ASize)
    {
        Sum += A[count];
        if(Sum == Ave)
        {
            Sum = 0;
            i++;
            if(i==2 && count != ASize-1)    return true;
        }
        count++;
    }
    return false;
}

总结：这个题目相对来说不是很难，因为要等分成3组，那么也就是说每一组的和和整组数据的平均值都相等，那么先求出这一组数的平均值，依次从头开始比较，看什么时候等于这个平均值，则算作一个切割点，当切割点有两个了，同时这个切割点不是数据的最后一位，那么就认为这个数据是有效的。

3、最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。
示例 2：
输入: “cbbd”
输出: “bb”

#define MAX(a, b)       (a>b) ? a : b
int SLen;

int IsPalindrome(char * s, int Left, int Right)
{
    int RightTemp=Right, LeftTemp=Left;
    while(RightTemp<SLen && LeftTemp>=0 && s[LeftTemp]==s[RightTemp])
    {
        RightTemp++;
        LeftTemp--;
    }
    return RightTemp - LeftTemp -1;
}

char * longestPalindrome(char * s){
    
    SLen = strlen(s);
    if(SLen <= 1) return s;

    int i,len=0;
    int start=0, end=0;

    for(i=0;i<SLen;i++)
    {
        len = MAX( IsPalindrome(s, i, i+1), IsPalindrome(s, i, i) );
        if (len > (end - start))
        {
            start = i - (len - 1) / 2;
            end = i + len / 2;
        }
    }
    char *result = (char*) malloc (end-start + 2);
    result[end-start+1] = '\0';
    for(int i = 0; i < end-start+1; i++)
        result[i] = s[start + i];
    return result;
}

总结： 这个题目当中，要判断最长回文子串，那也就是说必须要遍历所有的元素，因此依次判断以这个元素为中心的最长回文子串是多少，在这里需要注意一点的是要注意回文子串的长度为奇数和偶数的区别，模块化设计的思想在这里很方便自己理解代码，底层函数只判断传入的字串的两边扩散的最长回文子串为多少就可，在顶层函数中依次传入奇数值和偶数值，最终输出预期的字符串就可。