Question

面试题 10.02. 变位词组

English Version

题目描述

编写一种方法，对字符串数组进行排序，将所有变位词组合在一起。变位词是指字母相同，但排列不同的字符串。

注意：本题相对原题稍作修改

示例:

输入: ["eat", "tea", "tan", "ate", "nat", "bat"],
输出:
[
  ["ate","eat","tea"],
  ["nat","tan"],
  ["bat"]
]

说明：

• 所有输入均为小写字母。
• 不考虑答案输出的顺序。

解法

方法一

class Solution:
  def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
    chars = defaultdict(list)
    for s in strs:
      k = ''.join(sorted(list(s)))
      chars[k].append(s)
    return list(chars.values())

class Solution {
  public List<List<String>> groupAnagrams(String[] strs) {
    Map<String, List<String>> chars = new HashMap<>();
    for (String s : strs) {
      char[] t = s.toCharArray();
      Arrays.sort(t);
      String k = new String(t);
      chars.computeIfAbsent(k, key -> new ArrayList<>()).add(s);
    }
    return new ArrayList<>(chars.values());
  }
}

class Solution {
public:
  vector<vector<string>> groupAnagrams(vector<string>& strs) {
    unordered_map<string, vector<string>> chars;
    for (auto s : strs) {
      string k = s;
      sort(k.begin(), k.end());
      chars[k].emplace_back(s);
    }
    vector<vector<string>> res;
    for (auto it = chars.begin(); it != chars.end(); ++it) {
      res.emplace_back(it->second);
    }
    return res;
  }
};

func groupAnagrams(strs []string) [][]string {
  chars := map[string][]string{}
  for _, s := range strs {
    key := []byte(s)
    sort.Slice(key, func(i, j int) bool {
      return key[i] < key[j]
    })
    chars[string(key)] = append(chars[string(key)], s)
  }
  var res [][]string
  for _, v := range chars {
    res = append(res, v)
  }
  return res
}

function groupAnagrams(strs: string[]): string[][] {
  const map = new Map<string, string[]>();
  for (const s of strs) {
    const k = s.split('').sort().join();
    map.set(k, (map.get(k) || []).concat([s]));
  }
  return [...map.values()];
}

use std::collections::HashMap;

impl Solution {
  pub fn group_anagrams(strs: Vec<String>) -> Vec<Vec<String>> {
    let mut map = HashMap::new();
    for s in strs {
      let key = {
        let mut cs = s.chars().collect::<Vec<char>>();
        cs.sort();
        cs.iter().collect::<String>()
      };
      map.entry(key)
        .or_insert(vec![])
        .push(s);
    }
    map.into_values().collect()
  }
}