判断回文串

分析

回文串，从前往后读和从后往前读是一样的，例如“abcba”。
本文只考虑字母和数字字符，忽略字母的大小写，将空字符串定义为有效的回文串。

代码

一开始我的思路是将字符串遍历，去除空格等只留下字符和数字，然后利用reverse函数判断。
这种方法不管是不是回文串都要把字符串遍历一遍，耗时太久。

    bool isPalindrome(string s)
    {
        string s_dORa= "";
       	//取出字符和数字
        for (int i = 0; i < s.size(); ++i)
        {
            if ((isdigit(s[i]) || isalpha(s[i])) && s[i] >= 'a')
                s_dORa += s[i];
            else if ((isdigit(s[i]) || isalpha(s[i])) && s[i] < 'a')
                s_dORa += char(s[i] + 32);
        }

        string tmp = s_dORa;
        reverse(s_dORa.begin(), s_dORa.end());
        if (s_dORa == tmp)
            return true;
        return false;
    }

后来就想着不如前后一起查找，然后进行对比，非回文串可以很快就返回结果。

    bool isPalindrome(string s) {
        int i = 0;  //从前向后
        int j = s.size() - 1;  //从后向前
        while (i < j)
        {
            bool IisDorA = isdigit(s[i]) || isalpha(s[i]);  //s[i]是否为字母或数字
            bool JisDorA = isdigit(s[j]) || isalpha(s[j]);  //s[j]是否为字母或数字
            if (IisDorA && JisDorA)
            {
                //前后都是字母或者数字
                //不是对应关系则返回false，否则i继续向后查找，j继续向前查找
                if (tolower(s[i]) != tolower(s[j]))
                    return false;
                ++i; 
                --j;
            }
            else if (IisDorA)
            {
                //s[i]是数字或字母，s[j]不是
                --j;
            }
            else if (JisDorA)
            {
                //s[j]是数字或字母，s[i]不是
                ++i;
            }
            else
            {
                //s[i]和s[j]都不是数字和字母
                ++i;
                --j;
            }
        }
        return true;
    }

测试用例

示例 1:
输入: “A man, a plan, a canal: Panama”
输出: true

示例 2:
输入: “race a car”
输出: false

拓展

给定一个非空字符串 s，最多删除一个字符。判断是否能成为回文字符串。
提供一种思路：依然是i、j前后一起遍历，当发现s[i]和s[j]不相等时，要么i+1，要么j-1，然后继续遍历和判断。

    bool validPalindrome(string s) {
        int i = 0;  //首位开始位置
        int j = s.size() - 1;  //末尾开始位置
        int flag = 0;  //记录前后不一致的次数

        while (i < j)
        {
            //前后都是字母或者数字
            //不是对应关系要么i+1、j不变，要么i不变、j+1
            bool IisAorD = isalpha(s[i]) || isdigit(s[i]);  //s[i]是字符或数字
            bool JisAorD = isalpha(s[j]) || isdigit(s[j]);  //s[i]是字符或数字
            if (IisAorD && JisAorD)
            {
                if (s[i] == s[j])
                {
                    ++i;
                    --j;
                }
                else if(flag == 2)
                {
                    //i+1、j不变，i不变、j+1两种方式都不行
                    return false;
                }
                else if (flag == 0)
                {
                    //i+1、j不变的情况
                    ++i;
                    ++flag;
                }
                else if (flag == 1)
                {
                    //i不变、j-1的情况，注意i要复位
                    --j;
                    --i;
                    ++flag;
                }
            }
            else if (IisAorD)
            {
                //s[i]是数字或字母，s[j]不是
                --j;
            }
            else if (JisAorD)
            {
                //s[j]是数字或字母，s[i]不是
                ++i;
            }
            else
            {
                //s[i]和s[j]都不是数字和字母
                ++i;
                --j;
            }
        }
        return true;
    }