【LeetCode 热题 100】49. 字母异位词分组 | python【中等】0

学起来，为了更好的明天！

题目：

49. 字母异位词分组

给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

字母异位词 是由重新排列源单词的所有字母得到的一个新单词。

注意点：

1.学会用排序sorted(x)判断他们是否字母一样，且字母顺序一样

2.用字典储存，减少遍历时间和判断时间（不然每个单词得遍历已有大列表的所有首位单词字母）

标准做法：

将遍历过的存为字典，在之后计算target-a的时候搜索，时间复杂度O(Nklogk)【N：单词数，k：每个单词的字母数（soted排序要nlogn）】

class Solution(object):
    def groupAnagrams(self, strs):
        """
        :type strs: List[str]
        :rtype: List[List[str]]
        """
        table = {}
        
        # 遍历输入的字符串列表
        for s in strs:
            # 将字符串 s 的字符按字母顺序排序后重新拼接成一个字符串
            # 这样，所有字母异位词都会得到相同的排序结果
            s_ = "".join(sorted(s))
            
            # 检查排序后的字符串 s_ 是否已经在字典中
            if s_ not in table:
                # 如果 s_ 不在字典中，创建一个新的键 s_，并将当前字符串 s 作为值的第一个元素
                table[s_] = [s]
            else:
                # 如果 s_ 已经在字典中，将当前字符串 s 添加到对应的列表中
                table[s_].append(s)
        
        # 返回字典的所有值（即分组后的字母异位词列表）
        return list(table.values())

自己的做法：【未做出来】

用列表做的，实在做不出来了，每次搜索字母都要遍历一遍，超高复杂度，还跟顺序有关，好不容易可以识别数量了，又不能识别顺序。

class Solution(object):
    def groupAnagrams(self, strs):
        """
        :type strs: List[str]
        :rtype: List[List[str]]
        """

        an = [[strs[0]]]
        for word in strs[1:]:   # 未放入
            l = len(an)
            for j in range(l):
                word2 = an[j][0]    # 已有
                if word2:
                    for letter in word:
                        if letter in word2:
                            word2 = word2.replace(letter, "")
                        else:
                            break                        
                
                    if word2 == "":    # 一样
                        an[j].append(word)
                    else:
                        l -= 1

                else:
                    if word == "":
                        an[j].append(word)
                    else:
                        l -= 1
                    

            if l == 0:  # 全不一样
                an.append([word])
                
           
        return an

1.错：一样的单词会被删掉

class Solution(object):
    def groupAnagrams(self, strs):
        """
        :type strs: List[str]
        :rtype: List[List[str]]
        """
        pre = []
        an = []
        for i,word1 in enumerate(strs):
            
            if word1 in pre:
                pass
            else:
                an0=[word1]
                #an0.append(word1)
                pre.append(word1)
                
                for word2 in strs[i+1:]:
                    if word2 in pre:
                        pass
                    else:
                        num = 0
                        for letter1 in word1:
                            num += 1
                            for letter2 in word2:
     
                                if letter1 == letter2:
                                    num-=1
                                    break
                           
                        if num == 0:
                            an0.append(word2)
                            pre.append(word2)
                an.append(an0)
        return an
                            
                
        

2.错：不能识别字母数量

class Solution(object):
    def groupAnagrams(self, strs):
        """
        :type strs: List[str]
        :rtype: List[List[str]]
        """
        an = [[strs[0]]]
        for word in strs[1:]:
            l = len(an)
            for j in range(l):
                word2 = an[j][0]
                num = 0
                for letter in word2:
                    num += 1
                    if letter in word:
                        num -= 1
                    else:
                        break                        
                if word2 == "":
                    num += 1
                    if word == "":
                        num -= 1
                if num == 0:    # 一样
                    an[j].append(word)
                else:
                    l -= 1

            if l == 0:  # 全部不一样
                an.append([word])
                
           
        return an