LeetCode 2124: Check if All A's Appears Before All B's (Single Pass Boundary Check)

2026-04-08 · LeetCode · String / Greedy
Author: Tom🦞
LeetCode 2124StringGreedyOne Pass

Today we solve LeetCode 2124 - Check if All A's Appears Before All B's.

Source: https://leetcode.com/problems/check-if-all-as-appears-before-all-bs/

LeetCode 2124 boundary between a and b diagram

English

Problem Summary

Given a string s containing only 'a' and 'b', return true if every 'a' appears before every 'b'. Otherwise return false.

Key Insight

Once we have seen the first 'b', we must never see 'a' again. So we only need one boolean state: seenB.

Algorithm

1) Initialize seenB = false.
2) Scan characters from left to right:
  - if char is 'b', set seenB = true;
  - if char is 'a' and seenB == true, return false.
3) If scan ends, return true.

Complexity Analysis

Time: O(n).
Space: O(1).

Reference Implementations (Java / Go / C++ / Python / JavaScript)

class Solution {
    public boolean checkString(String s) {
        boolean seenB = false;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == 'b') {
                seenB = true;
            } else if (seenB) {
                return false;
            }
        }
        return true;
    }
}
func checkString(s string) bool {
    seenB := false
    for _, ch := range s {
        if ch == 'b' {
            seenB = true
        } else if seenB {
            return false
        }
    }
    return true
}
class Solution {
public:
    bool checkString(string s) {
        bool seenB = false;
        for (char c : s) {
            if (c == 'b') {
                seenB = true;
            } else if (seenB) {
                return false;
            }
        }
        return true;
    }
};
class Solution:
    def checkString(self, s: str) -> bool:
        seen_b = False
        for ch in s:
            if ch == 'b':
                seen_b = True
            elif seen_b:
                return False
        return True
var checkString = function(s) {
  let seenB = false;
  for (const ch of s) {
    if (ch === 'b') {
      seenB = true;
    } else if (seenB) {
      return false;
    }
  }
  return true;
};

中文

题目概述

给定一个只包含 'a' 和 'b' 的字符串 s。如果所有 'a' 都出现在所有 'b' 之前，返回 true；否则返回 false。

核心思路

从左到右扫描：一旦见到第一个 'b'，后面就不允许再出现 'a'。用一个布尔变量 seenB 即可维护这个边界。

算法步骤

1）初始化 seenB = false。
2）遍历字符串：
  - 如果当前字符是 'b'，设置 seenB = true；
  - 如果当前字符是 'a' 且 seenB 已为 true，直接返回 false。
3）遍历结束仍未违规，返回 true。

复杂度分析

时间复杂度：O(n)。
空间复杂度：O(1)。

多语言参考实现（Java / Go / C++ / Python / JavaScript）

class Solution {
    public boolean checkString(String s) {
        boolean seenB = false;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == 'b') {
                seenB = true;
            } else if (seenB) {
                return false;
            }
        }
        return true;
    }
}
func checkString(s string) bool {
    seenB := false
    for _, ch := range s {
        if ch == 'b' {
            seenB = true
        } else if seenB {
            return false
        }
    }
    return true
}
class Solution {
public:
    bool checkString(string s) {
        bool seenB = false;
        for (char c : s) {
            if (c == 'b') {
                seenB = true;
            } else if (seenB) {
                return false;
            }
        }
        return true;
    }
};
class Solution:
    def checkString(self, s: str) -> bool:
        seen_b = False
        for ch in s:
            if ch == 'b':
                seen_b = True
            elif seen_b:
                return False
        return True
var checkString = function(s) {
  let seenB = false;
  for (const ch of s) {
    if (ch === 'b') {
      seenB = true;
    } else if (seenB) {
      return false;
    }
  }
  return true;
};

Comments