LeetCode - 125. 验证回文串

描述

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

说明：本题中，我们将空字符串定义为有效的回文串。

示例 1:

输入: "A man, a plan, a canal: Panama"
输出: true
示例 2:

输入: "race a car"
输出: false

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/valid-palindrome/

 

求解

   class Solution {
    private:
    public:
        // 方法一，筛选出原始字符串中仅有数字和字母组成的部分，然后进行指针对撞，时间复杂度O(N)，空间复杂度O(N)
        bool isPalindrome_useExtraSpace(string s) {
            // 筛选出原始字符串中仅有数字和字母组成的部分
            string str;
            std::copy_if(s.begin(), s.end(), std::back_inserter(str), [](char c) { return isalnum(c); });
            // 将字母全部转换为小写
            std::transform(str.begin(), str.end(), str.begin(), [](char c) {
                if (isalpha(c)) {
                    return (char) tolower(c);
                }
                return c;
            });

            // 小于2个字符肯定是回文串
            const int n = str.size();
            if (n < 2) {
                return true;
            }

            // 指针对撞
            int low = 0;
            int high = n - 1;
            while (low < high) {
                if (str[low] != str[high]) {
                    return false;
                }
                ++low;
                --high;
            }
            return true;  // 字符串长度是奇数，则同时指到中间字符结束，若为偶数，则low - high = 1;
        }

        // 方法二，直接在形参s中操作，去除数字和字母外的其他字符，然后进行指针对撞，时间复杂度O(N)，空间复杂度O(1)
        bool isPalindrome_2e(string s) {
            // 筛选出原始字符串中仅有数字和字母组成的部分
            int len = 0;  // 统计有效字符数量
            std::copy_if(s.begin(), s.end(), s.begin(), [&len](char c) {
                if (isalnum(c)) {
                    ++len;
                    return true;
                }
                return false;
            });
            // 将字母全部转换为小写
            std::transform(s.begin(), s.end(), s.begin(), [](char c) {
                if (isalpha(c)) {
                    return (char) tolower(c);
                }
                return c;
            });

            // 指针对撞
            int low = 0;
            int high = len - 1;
            while (low < high) {
                if (s[low] != s[high]) {
                    return false;
                }
                ++low;
                --high;
            }
            return true;  // 字符串长度是奇数，则同时指到中间字符结束，若为偶数，则low - high = 1;
        }

        // 方法二，不使用算法copy_if, transform, 手写循环实现，时间复杂度O(N)，空间复杂度O(1)
        bool isPalindrome_2e_prove(string s) {
            // 筛选出原始字符串中仅有数字和字母组成的部分
            int k = 0; // [0...k)中存储过滤后，且转换大小写的字符，循环不变量
            for (auto c : s) {
                if (isalnum(c)) {
                    s[k++] = char(tolower(c));
                }
            }

            // 指针对撞
            int low = 0;
            int high = k - 1;
            while (low < high) {
                if (s[low] != s[high]) {
                    return false;
                }
                ++low;
                --high;
            }
            return true;  // 字符串长度是奇数，则同时指到中间字符结束，若为偶数，则low - high = 1;
        }

        // 方法三，使用算法翻转字符串后比较字符串是否相等，时间复杂度O(N)，空间复杂度O(N)
        bool isPalindrome(string s) {
            // 筛选出原始字符串中仅有数字和字母组成的部分
            int k = 0; // [0...k)中存储过滤后，且转换大小写的字符，循环不变量
            for (auto c : s) {
                if (isalnum(c)) {
                    s[k++] = char(tolower(c));
                }
            }
            s.erase(s.begin() + k, s.end());

            string rs(s.crbegin(), s.crend());
            return rs == s;  // 字符串长度是奇数，则同时指到中间字符结束，若为偶数，则low - high = 1;
        }
    };