LeetCode:65. 有效数字

本文详细解析了LeetCode题目65. ValidNumber的解决方案,采用有限状态机的方法来验证输入字符串是否为有效的数字。文章通过具体示例介绍了实现思路及代码细节。

题目

LeetCode: 65. Valid Number

验证给定的字符串是否为数字。

示例:

"0" => true
" 0.1 " => true
"abc" => false
"1 a" => false
"2e10" => true

思路

有限状态机
序列的情形是有限的,我觉得这个题有限状态机非常合适。
首先将真正需要处理的序列取出,也就是取出前面空格和后面空格的序列,这之间有几种情况:

  1. 空格,继续循环
  2. 碰到数字,终止循环
  3. 碰到小数点,终止循环
  4. 碰到其他字符,返回false

取出序列的时候要注意一下特殊情况,那就是只有一个.,则返回false

然后分为四种情况考虑:

  1. 数字,直接跳过,检查下一个位置
  2. 小数点,看小数点前是否有e或者别的小数点
  3. e,e的情况看前面是否有数字序列,是否有别的e,然后需要判断e后的加减号
  4. 其他字符,返回false

代码

查看更多LeetCode代码

class Solution {
public:
    bool isNumber(string s) {
        //我的解法是有限状态机,将所有状态考虑进行排除
        bool e = false;
        bool ch = false;
        bool num = false;
        int front = 0;
        int back = s.size() - 1;
        //由于序列存在前面和后面有空格的情况,所以先去除前后空格
        //去除前面空格
        for (front; front < s.size(); front++)
        {
            if (s[front] == ' ')
                continue;
            else if ((s[front] <= '9' && s[front] >= '0') || (s[front] == '.'))
                break;
            else if (s[front] == '+' || s[front] == '-')
            {
                //遇到加号减号就将前下标放至+-之后
                front++;
                break;
            }
            else
                return false;
        }
        //当front和size相同,说明序列全为空格
        if (front == s.size())
            return false;
        //去除后面空格
        for (back; back >= 0; back--)
        {
            if (s[back] == ' ')
                continue;
            else if ((s[back] <= '9' && s[back] >= '0') || (s[back] == '.'))
                //考虑'.'的情况是因为存在序列'2.'也是合法序列
                break;
            else
                return false;
        }
        if (front == back && s[front] == '.')
            //存在一个序列只有一个点,特殊处理特殊情况
            return false;
        for (int i = front; i <= back; i++)
        {
            //四种情况:
            //1.数字,直接跳过,检查下一个位置
            //2.小数点,看小数点前是否有e或者别的小数点
            //3.e,e的情况看前面是否有数字序列,是否有别的e
            //4.其他字符
            if (s[i] <= '9' && s[i] >= '0')
            {
                num = true;
                continue;
            }
            else if (s[i] == '.')
            {
                if (ch == true || e == true)
                    return false;
                else
                    ch = true;
            }
            else if (s[i] == 'e')
            {
                if (num == false || e == true)
                    return false;
                else
                    e = true;
                if (s[i + 1] == '+' || s[i + 1] == '-')
                    i++;
            }
            else
                return false;
        }
        return true;
    }
};
### LeetCode 128. 最长连续序列 解法 #### 方法一:基于哈希表的优化算法 此方法的核心思想在于利用无序集合 `unordered_set` 来存储数组中的所有元素,从而实现 O(1) 时间复杂度的查找操作。对于每一个数 `num`,如果它不是某个更小数的一部分,则尝试从该数出发构建最长可能的连续子序列。 以下是具体实现代码: ```cpp class Solution { public: int longestConsecutive(vector<int>& nums) { unordered_set<int> num_set; for (const int& num : nums) { num_set.insert(num); } int longestStreak = 0; for (const int& num : num_set) { if (!num_set.count(num - 1)) { // 如果当前数不是任何较小数的部分 int currentNum = num; int currentStreak = 1; while (num_set.count(currentNum + 1)) { // 尝试扩展更大的部分 currentNum += 1; currentStreak += 1; } longestStreak = max(longestStreak, currentStreak); // 更新最大长度 } } return longestStreak; } }; ``` 这种方法的时间复杂度为 O(n)[^1],其中 n 是输入数组的大小。这是因为每个数最多只会被访问两次——一次用于检查其是否存在作为起点,另一次用于计算以其开头的最大连续序列。 --- #### 方法二:Python 实现的哈希表解法 另一种类似的思路可以采用 Python 编写,逻辑基本一致,但更加简洁易懂。这里我们同样借助集合来完成快速查询的任务。 下面是对应的 Python 版本代码: ```python class Solution: def longestConsecutive(self, nums: list[int]) -> int: num_set = set(nums) longest_streak = 0 for num in num_set: if num - 1 not in num_set: # 当前数字是最小值的情况 current_num = num current_streak = 1 while current_num + 1 in num_set: # 向右寻找连续数值 current_num += 1 current_streak += 1 longest_streak = max(longest_streak, current_streak) return longest_streak ``` 这段代码的关键点在于只处理那些可能是某一段连续区间起始位置的数字(即不存在比它们还小的一个单位),因此能够有效减少不必要的迭代次数[^2]。 --- #### 复杂度分析 - **时间复杂度**: 上述两种方法均具有线性时间复杂度 O(n),因为尽管存在嵌套循环结构,但实际上每个元素至多会被考察常数次。 - **空间复杂度**: 使用了一个额外的数据结构(如 C++ 中的 `unordered_set` 或者 Python 的内置 `set` 类型)用来辅助存储原始数据副本,故总体占用的空间也为 O(n)。 --- #### 注意事项 虽然官方给出的第一种解决方案理论上表现良好,但在某些特殊情况下可能会退化到平方级别性能。例如当输入完全逆序排列时,每次都需要重新扫描整个剩余未匹配项列表才能得出结论[^1]。相比之下,第二种方案则更为稳健可靠一些。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值