算法题集锦

<span style="font-family: 微软雅黑, Verdana, sans-serif, 宋体; font-size: 12.5px; background-color: rgb(255, 255, 255);">题目：</span><span style="background-color: rgb(255, 255, 255); padding: 0px; margin: 0px; font-family: Arial; font-size: 14px; line-height: 26px;">定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素。</span>

要求函数min、push以及pop的时间复杂度都是O(1)。

思路：使用一个辅助栈来保存最小元素，这个解法简单不失优雅。设该辅助栈名字为minimum stack，其栈顶元素为当前栈中的最小元素。

            要获取当前栈中最小元素，只需要返回minimum stack的栈顶元素即可。

            每次执行push操作，检查push的元素是否小于或等于minimum stack栈顶元素。如果是，则也push该元素到minimum stack中。

            当执行pop操作的时候，检查pop的元素是否与当前最小值相等。如果相同，则需要将改元素从minimum stack中pop出去。

#include<stdio.h>
#include <iostream>
#include <stack> 
using namespace std ;
 
struct StackGetMin {
      stack<int> elements;
      stack<int> minStack;
      void push(int x) {
        elements.push(x);
        if (minStack.empty() || x <= minStack.top()) //push的元素小于当前minStack的最小元素，则push到minStack中
          minStack.push(x);
      }
      bool pop() {
        if (elements.empty()) return false;
        if (elements.top() == minStack.top()) //如果原始栈栈顶元素与minStack栈顶元素相同，则将该元素也从minStack中pop出去。
          minStack.pop();
        elements.pop();
        return true;
      }
      bool getMin(int &min) {
        if (minStack.empty()) {
          return false;
        } else {
          min = minStack.top();
          return true;
        }
      }
};
 
int main()
{
    StackGetMin stackMin;
    stackMin.push(2);
    stackMin.push(6);
    stackMin.push(4);
    stackMin.push(1);
    stackMin.push(5);
    int min =0;
    stackMin.getMin(min );
    cout<<min;
    getchar();
    return 0;
}

递归实现回文判断：

#include <iostream>
 2 using namespace std;
 3 
 4 bool isPalindrome(char str[], size_t n)
 5 {
 6     if (n<=1)
 7     {
 8         return true;
 9     }
10     else if (str[0]==str[n-1])
11     {
12         return isPalindrome(str+1,n-2);
13     }
14     else
15         return false;
16 }
17 
18 int main()
19 {
20     char str[20];
21     cin>>str;
22     cout<<(isPalindrome(str,strlen(str))?"Yes":"No")<<endl;
23 }

题目：
输入一个整形数组，数组里有正数也有负数。
数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。
求所有子数组的和的最大值。要求时间复杂度为O(n)。

例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5，和最大的子数组为3, 10, -4, 7, 2，
因此输出为该子数组的和18。

/******************************************************************** 
   3.求子数组的最大和 
   题目： 
   输入一个整形数组，数组里有正数也有负数。 
   数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。 
   求所有子数组的和的最大值。要求时间复杂度为O(n)。 
 
   例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5，和最大的子数组为3, 10, -4, 7, 2， 
   因此输出为该子数组的和18。 
*********************************************************************/  
/******************************************************************** 
    问题描述符合动态规划最优子结构的要求。 
    关键在于转换为求出以每一个元素结尾的和最大子数组的问题求解。 
 
    设b[i]表示以a[i]结尾的子数组的最大子段和，即： 
    b[i]=max{sum(a[j~k])},其中0<=j<=i，j<=k<=i。 
    因此对于数组a[0~n]的最大字段和为max{b[i]}，其中0<=i<n。 
 
    在计算b[i]时，可以考虑以下三种情况： 
    1，b[i] = b[i-1]+a[i]，当b[i-1]>0时，这时候的b[i]中包含a[i]。 
    2，b[i] = a[i]，当b[i-1]<=0，这时候以a[i]重新作为b[i]的起点。 
    3，b[i]不包含a[i]的情况，这种情况在计算b[i]之前已经计算处结果，保存在b[0~i-1]中。最后计算max{b[i]}时会考虑到。 
 
    b[i] = max{b[i-1]+a[i]，a[i]}。 
 
    而数组a[0~n]则为max{b[i]}。在实现时，可以省略数组b[i]。 
*********************************************************************/  
bool SAMV_GetSubArraySumMax(const int *pDataArray, int nArraySize, int *pSubArrayMaxSum, int *pSubArrayBeginIndex, int *pSubArrayEndIndex)  
{  
    // 参数有效性  
    if (pDataArray == NULL || nArraySize<=0)  
    {  
        return false;  
    }  
      
    // 临时变量  
    int bi_1 = pDataArray[0];    // 记录a0-ai_1形成的和最大自数组的和值  
    int maxbi = pDataArray[0];   // 记录bi_1的最大值  
    int subBeginIndex = 0;  
    int subEndIndex = 0;  
    int maxSubBeginIndex = 0;  
    int maxSubEndIndex = 0;  
  
    // 求解  
    for (int i=1; i<nArraySize; i++)  
    {  
        // 求得以a[i]结尾的和最大子数组值  
        if (bi_1 > 0)  
        {  
            bi_1 += pDataArray[i];  
            subEndIndex = i;  
        }  
        else  
        {  
            bi_1 = pDataArray[i];  
            subBeginIndex = i;  
            subEndIndex = i;  
        }         
  
        // 求所有自数组中和最大值  
        if (maxbi < bi_1)  
        {  
            maxbi = bi_1;  
            maxSubBeginIndex = subBeginIndex;  
            maxSubEndIndex = subEndIndex;  
        }  
    }  
  
    // 得到输出参数  
    if (pSubArrayMaxSum != NULL)  
    {  
        *pSubArrayMaxSum = maxbi;  
    }  
    if (pSubArrayBeginIndex != NULL)  
    {  
        *pSubArrayBeginIndex = maxSubBeginIndex;  
    }  
    if (pSubArrayEndIndex != NULL)  
    {  
        *pSubArrayEndIndex = maxSubEndIndex;  
    }  
      
    return true;  
}