算法练习之一

今天瞎逛论坛，看到一个很不错的题目，拿来练练手，记录一下，以便日后回看。

先看题目：

输入一个表示整数的字符串，把该字符串转换成整数并输出，例如输入字符串"345"， 则输出整数 345。
给定函数原型 int StrToInt(const char *str) ，完成函数 StrToInt，实现字符串转换成整数的功能，不得用库函数 atoi（即便准许使用，其对于溢出情况的处理也达不到题目的要求.)

输入：　　　　　　　输出：

123　　　　　　　　123

-123　　　　　　　　-123

23a4　　　　　　　　23

2147483648　　　　2147483647

-2147483649　　　-2147483648

10522545459　　　2147483647

题目分析：

初看这套题貌似很简单，但是真正开始动手敲键盘的时候才发现里面有太多的陷阱。

陷阱一：是否考虑到了正负号的问，即代码能正确处理123与-123

陷阱二：是否考虑到字符串中有非法字符，例如23a4，该如何处理。我们目前假设输出23是正确的

陷阱三：如果输入的字符串超出了int型整数所能表示的最大范围怎么办？例如输入10522545459，我们知道int型最大范围为-2147483648~2147483647。我们假设一旦溢出时，输出最大　　　　或最小数。在写代码过程中，溢出问题是最大的障碍。

陷阱四：字符串是空怎么办？默认字符串为空是输出0.

OK，将以上陷阱考虑清楚以后开始写代码了

#include <iostream>
#include <string.h>
#include <limits>
#include <limits.h>
using namespace std;

const int MAXSIZE=1000;
enum Status{ kValid = 0, kInvalid};
int g_nStatus = kValid;

/*版本一
此版本基本实现了将字符串型整数转换为int整数，但是对于一些非法的输入依旧是不行的
例如：23a4，它只会返回0，而不是23；还有一旦越界后，它也是输出的0
*/
int StrToInt( const char* str )
{
    g_nStatus = kInvalid;
    long long num=0;

    if( str != NULL )
    {
        const char* digit = str;
        bool minus = false;

        if( *digit == '+' )
        {
            digit++;
        }
        else if( *digit == '-' )
        {
            digit++;
            minus=true;
        }

        while( *digit != '' )
        {
            if( *digit >='0' && *digit <='9' )
            {
                num = num*10 + ( *digit - '0' );

                if( num > numeric_limits<int>::max() )
                {
                    num=0;
                    break;
                }
                digit++;
            }
            else
            {
                num=0;
                break;
            }
        }
        if( *digit == '' )
        {
            g_nStatus = kValid;
            if( minus )
            {
                num=0-num;
            }
        }
    }

    return static_cast<int>(num);
}

/*版本二：
此版本较上面的有了更好的改进，首先对于溢出问题有了很好的处理，INT_MAX是标准库里定义的int型最大值INT_MIN是最小值
其次，在遇到非法字符时，循环跳出，但之前记录的数依旧会返回，也就是实现了23a4返回23的功能。
小贴士：INT_MAX=2147483647   INT_MIN=-2147483648 (需要头文件limits.h) 这也是( cur-1 > INT_MAX - res*10 )这样写的原因

但是，（显然这个版本还是有错），如果输入10522545459他会输出1932610867，
原因是如果之前所得数已经较大了，再乘10就必定溢出，也就是超出int所能表示最大范围，会发生逻辑错误。
*/
int StrToInt_2( const char* str )
{
    int res=0;
    int i=0;
    int signal = '+';
    int cur;

    if( !str )
    {
        return 0;
    }

    while( isspace(str[i]))
    {
        i++;
    }

    if( str[i] == '+' || str[i] == '-')
    {
        signal = str[i];
        i++;
    }

    while( str[i] >= '0' && str[i] <= '9' )
    {
        cur=str[i]-'0';
        if( (signal == '+' ) && ( cur > INT_MAX - res*10 ) )
        {
            res=INT_MAX;   
            break;
        }
        else if( (signal == '-' ) && ( cur-1 > INT_MAX - res*10 ) )
        {
            res=INT_MIN;   
            break;
        }

        res=res*10+cur;
        i++;
    }

    return signal=='-'?-res:res;
}

/*版本三：
此版本我没有想出来，而是参考july的博文写出的。
它的做法最重要的是巧妙的规避了计算 n*10 这一乘法步骤，转换成计算除法 MAX_INT/10 代替，不能不说此法颇妙。
这样的话在超出int型最大范围前就能提早发现它将要溢出。关键代码在***处
目前这个版本的代码是最为接近正确答案的了，不过也许会有更好的代码，待日后发现再说吧！

这个版本所存在的问题就显得无足轻重了：它的实现与 linux 内核的 atoi 函数的实现, 都有一个共同的问题: 
即使出错, 函数也返回了一个值, 导致调用者误认为自己传入的参数是正确的, 但是可能会导致程序的其他部分产生莫名的错误且很难调试”。
*/
int StrToInt_3( const char* str )
{
    const int MAX_DIV=INT_MAX/10;
    const int MIN_DIV=INT_MIN/10;
    const int MAX_R=INT_MAX%10;
    const int MIN_R=INT_MIN%10;
    //另一种实现，可以不需要limit.h的头文件，便于移植
    /*
    const int MAX = (int)((unsigned)~0 >> 1);
    const int MIN = -(int)((unsigned)~0 >> 1) - 1;
    const int MAX_DIV = (int)((unsigned)~0 >> 1) / 10;
    const int MIN_DIV = (int)((((unsigned)~0 >> 1) + 1) / 10);
    const int MAX_R = (int)((unsigned)~0 >> 1) % 10;
    const int MIN_R = (int)((((unsigned)~0 >> 1) + 1) % 10);
    */

    int res=0;
    int i=0;
    int signal = '+';
    int cur;

    if( !str )
    {
        return 0;
    }

    while( isspace(str[i]))
    {
        i++;
    }

    if( str[i] == '+' || str[i] == '-')
    {
        signal = str[i];
        i++;
    }

    while( str[i] >= '0' && str[i] <= '9' )
    {
        cur=str[i]-'0';
        if( (signal == '+' ) && ( res > MAX_DIV || (res == MAX_DIV && cur >= MAX_R)) )  //***
        {
            res=INT_MAX;   /*或res=MAX*/
            break;
        }
        else if( (signal == '-' ) && ( res > MIN_DIV || (res == MIN_DIV && cur >= MIN_R)) ) //***
        {
            res=INT_MIN;   /*或res=MIN*/
            break;
        }

        res=res*10+cur;
        i++;
    }

    return signal=='-'?-res:res;
}


int main( void )
{
    char str[MAXSIZE];
    memset( str, 0, MAXSIZE);
    while( cin.getline( str, MAXSIZE ))
    {
        cout<<str<<"          "<<StrToInt_2(str)<<endl;
    }

    return 0;
}

写完这道题以后，也给我自己提个醒：

1.拿到一道题时候要充分考虑输入的各种情况，能够对所有非法输入有一个正确处理，这就是所谓的程序的鲁棒性（健壮性）

2.所有题目题目的解法都离不开基础，程序中用的都是基础的数据结构。int+array=all

3.善于分析题目中隐含的小知识，细节决定成败。这也是我目前所或缺的。