---
id: 49
title: Group Anagrams
difficulty: Medium
tags:
  - array
  - hash-table
  - string
  - sorting
status: Solved
date_solved: 2026-06-05
leetcode_url: https://leetcode.com/problems/group-anagrams/
review_needed: false
---

# 49. Group Anagrams

> [!info] **Problem Link**: [LeetCode - Group Anagrams](https://leetcode.com/problems/group-anagrams/)

## 📝 Problem Description

Given an array of strings `strs`, group the **anagrams** together. You can return the answer in **any order**.

An **Anagram** is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.

---

### 📥 Example 1
**Input:** `strs = ["eat","tea","tan","ate","nat","bat"]`
**Output:** `[["bat"],["nat","tan"],["ate","eat","tea"]]`

### 📥 Example 2
**Input:** `strs = [""]`
**Output:** `[[""]]`

### 📥 Example 3
**Input:** `strs = ["a"]`
**Output:** `[["a"]]`

---

## 💡 Approaches & Explanations

### Approach 1: Categorize by Sorted String
Two strings are anagrams if and only if their sorted versions are equal. We can use a hash map where the key is the sorted string and the value is a list of anagrams.
- **Time Complexity:** $\mathcal{O}(N \cdot K \log K)$ where $N$ is the number of strings and $K$ is the maximum length of a string.
- **Space Complexity:** $\mathcal{O}(N \cdot K)$

### Approach 2: Categorize by Character Count — *Optimal*
Instead of sorting, we can represent each string as a frequency array of size 26 (for 'a' to 'z'). Two strings are anagrams if their frequency arrays are identical.
1.  Initialize a hash map `res`.
2.  For each string in `strs`:
    - Create a count array of size 26, initialized to 0.
    - For each character in the string, increment its corresponding index in the count array.
    - Convert the count array to a tuple (to make it hashable) and use it as a key in `res`.
    - Append the original string to the list at that key.
3.  Return `res.values()`.

#### 📊 Complexity Analysis
- **Time Complexity:** $\mathcal{O}(N \cdot K)$ where $N$ is the number of strings and $K$ is the maximum length of a string. We iterate through each string and each character once.
- **Space Complexity:** $\mathcal{O}(N \cdot K)$ to store the result in the hash map.

---

## 💻 Code Implementations

### Python3
```python
from collections import defaultdict

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        res = defaultdict(list)  # mapping charCount to list of Anagrams

        for s in strs:
            count = [0] * 26  # a ... z
            for c in s:
                count[ord(c) - ord("a")] += 1
            
            # Convert list to tuple so it can be used as a key in dictionary
            res[tuple(count)].append(s)
            
        return list(res.values())
```

---

## 🧠 Key Takeaways & Lessons
- **Hashing Frequency Arrays:** Using a frequency array as a hash map key is a common technique for string problems where order doesn't matter (like anagrams).
- **Tuple conversion:** In Python, lists are mutable and cannot be used as dictionary keys. Converting them to tuples (which are immutable) solves this.
- **Asymptotic Optimization:** While sorting is often "fast enough," the character count approach is asymptotically superior for long strings.