How do you approach First Unique Character in a String?

Count the frequency of each character using a hash map.

What is the time complexity of First Unique Character in a String?

Time complexity: O(n). Space complexity: O(1) - at most 26 lowercase letters.

What are common mistakes on First Unique Character in a String?

Storing the current value before checking for its complement, which lets an element pair with itself. Reaching for a sort to deduplicate when a set does it in one pass - that swap quietly costs you the O(n). Using a plain object as the map when keys may be numbers or __proto__; a real hash-map type keeps key identity intact.

← Back to problems

First Unique Character in a String

EasyData Structures

Description

Given a string `s`, find the first non-repeating character in it and return its index. If it does not exist, return `-1`.

Example 1

Input: s = "leetcode"

Output: 0

Example 2

Input: s = "loveleetcode"

Output: 2

Example 3

Input: s = "aabb"

Output: -1

Constraints

- 1 <= s.length <= 10^5 - s consists of only lowercase English letters.

First Unique Character in a String: approach, complexity and pitfalls

An easy arrays & hashing problem, graded against 6 test cases (3 of them hidden).

The pattern: Arrays & Hashing

Hash maps and sets to trade memory for time - the most common first instinct in interviews.

Reach for it when you see: "Have I seen this before?", counting occurrences, or an O(n²) scan you want to make O(n).

More Arrays & Hashingproblems →

If you are stuck

Show the 3-step hint ladder

Count the frequency of each character using a hash map.
Iterate through the string again to find the first character with count 1.
Return the index of that character.

The optimal approach

Show the approach: Two Pass with Hash Map

First pass: count frequency of each character.

Second pass: find the first character with count 1.

Time: O(n)
Space: O(1) - at most 26 lowercase letters

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

Common Arrays & Hashing mistakes

These apply to the pattern as a whole, not just this problem.

Storing the current value before checking for its complement, which lets an element pair with itself.
Reaching for a sort to deduplicate when a set does it in one pass - that swap quietly costs you the O(n).
Using a plain object as the map when keys may be numbers or `__proto__`; a real hash-map type keeps key identity intact.