49. 字母异位词分组-优快云博客

49. 字母异位词分组

1. 题目描述

给定一个字符串数组 strs，请按字母异位词进行分组：能够通过重新排列字母变成同一个单词的字符串，放入同一组。

返回分组后的字符串数组，组与组之间、组内字符串的顺序都不限。

如果两个单词包含的字母及其出现次数完全相同，只是排列顺序可能不同，它们就是字母异位词。

例如 eat、tea、ate 可以分为一组。ab 和 aab 不能分为一组，因为 a 的数量不同。

示例 1：

输入：strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
输出：[["eat", "tea", "ate"], ["tan", "nat"], ["bat"]]

示例 2：

输入：strs = [""]
输出：[[""]]

示例 3：

输入：strs = ["a"]
输出：[["a"]]

数据范围：

字符串数量：1 <= strs.length <= 10000。
每个字符串的长度：0 <= strs[i].length <= 100，允许空字符串。
字符串仅包含小写英文字母。

2. 思路：排序后的字符串就是分组标签

把单词的字母按从小到大的顺序排列：

eat → aet
tea → aet
ate → aet

tan → ant
nat → ant

bat → abt

排序结果相同，就放进同一组。 这个排序结果可以看成单词的“分组标签”。

为什么成立？排序会保留每种字母及其数量，只统一它们的位置。因此，字母异位词排序后一定相同；排序后相同，也说明每种字母的数量相同。

注意，排序的是单词的副本。标签用来分类，答案里保存的仍然是原单词。

3. 处理流程

C++ 用哈希表保存“标签 → 一组原单词”的对应关系：

取出一个单词，复制到 key。
排序 key，得到标签。
将原单词加入 groups[key]。
所有单词处理完后，取出哈希表中的各组。

示例的过程如下：

当前单词	排序后的标签	对应组更新后
`eat`	`aet`	`["eat"]`
`tea`	`aet`	`["eat", "tea"]`
`tan`	`ant`	`["tan"]`
`ate`	`aet`	`["eat", "tea", "ate"]`
`nat`	`ant`	`["tan", "nat"]`
`bat`	`abt`	`["bat"]`

4. C++ 答案

groups[key] 在标签第一次出现时自动创建空组，随后用 push_back 加入原单词。

#include <algorithm>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map<string, vector<string>> groups;

        for (const string& word : strs) {
            string key = word;
            sort(key.begin(), key.end());
            groups[key].push_back(word);
        }

        vector<vector<string>> result;
        for (auto& entry : groups) {
            result.push_back(move(entry.second));
        }
        return result;
    }
};

最后的 move 将整组转移到结果中，避免再复制组里的字符串。

5. C 答案

C 版本也使用“排序后的字符串”作为标签。先为每个单词保存标签和原单词，再把所有记录按标签排序，相同标签就会相邻，可以连续取出一组。

排序后的记录：
abt → bat
aet → eat
aet → tea
aet → ate
ant → tan
ant → nat

同标签记录的内部顺序不影响答案。题目规定单词最长为 100，所以标签数组开 101 个位置，多出的一个位置保存字符串结束符 \0。

#include <stdlib.h>
#include <string.h>

typedef struct {
    char key[101];  // 最多 100 个字符，再留一个位置给 '\0'。
    char* word;
} Item;

static int compareChar(const void* a, const void* b) {
    return *(const unsigned char*)a - *(const unsigned char*)b;
}

static int compareItem(const void* a, const void* b) {
    const Item* left = a;
    const Item* right = b;
    return strcmp(left->key, right->key);
}

char*** groupAnagrams(char** strs, int strsSize,
                     int* returnSize, int** returnColumnSizes) {
    Item* items = malloc(strsSize * sizeof(Item));

    // 保存原字符串，排序它的副本作为标签。
    for (int i = 0; i < strsSize; ++i) {
        items[i].word = strs[i];
        strcpy(items[i].key, strs[i]);
        qsort(items[i].key, strlen(items[i].key), sizeof(char), compareChar);
    }

    // 相同标签排在一起后，就可以连续分组。
    qsort(items, strsSize, sizeof(Item), compareItem);

    char*** result = malloc(strsSize * sizeof(char**));
    *returnColumnSizes = malloc(strsSize * sizeof(int));
    *returnSize = 0;

    int start = 0;
    while (start < strsSize) {
        int end = start + 1;
        while (end < strsSize && strcmp(items[start].key, items[end].key) == 0) {
            ++end;
        }

        int group = *returnSize;
        int count = end - start;
        result[group] = malloc(count * sizeof(char*));
        (*returnColumnSizes)[group] = count;

        // 返回原单词的独立副本，而不是排序后的标签。
        for (int j = 0; j < count; ++j) {
            char* word = items[start + j].word;
            size_t bytes = strlen(word) + 1;
            result[group][j] = malloc(bytes);
            memcpy(result[group][j], word, bytes);
        }

        ++(*returnSize);
        start = end;
    }

    free(items);
    return result;
}

*returnSize 表示组数，(*returnColumnSizes)[i] 表示第 i 组有几个单词。返回字符串均为独立副本；调用方使用完后，应依次释放每个字符串、每组数组、最外层数组和列大小数组。

6. 复杂度与易错点

设 n 为单词数量，L 为最长单词长度（至少按 1 计算），S 为所有单词的总字符数。

C++ 平均时间：O(nL log(L + 1))。主要花在对每个单词排序，哈希表操作按平均情况分析。
C 时间：O(nL log(L + 1) + nL log(n + 1))。多了一次记录排序，比较两个标签最多需要 O(L) 时间；这里按常见的 O(t log t) 排序实现分析，C 标准本身不保证 qsort 的复杂度。
两版总空间：O(n + S)，包含返回结果。 C 的临时标签按题目上限固定占 101n 个字符，计入 O(n)。