用python写leetcode【3】 --有效的字母异位词(242)、实现 Trie (前缀树)（208）

有效的字母异位词(242)

题目

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的一个字母异位词。

示例 1:

输入: s = “anagram”, t = “nagaram”
输出: true
示例 2:

输入: s = “rat”, t = “car”
输出: false
说明:
你可以假设字符串只包含小写字母。

思路

很简单，统计每一个字母的次数是否一样

代码

     class Solution:
        def isAnagram(self, s: str, t: str) -> bool:
            s1=[0]*26
            s2=[0]*26
            for i in s:
                s1[ord(i)-ord('a')]+=1
            
            for i in t:
                s2[ord(i)-ord('a')]+=1
            
            for i in range(26):
                if s1[i]==s2[i]:
                    pass
                else:
                    return False
            
            return True

实现 Trie (前缀树)（208）

题目

实现一个 Trie (前缀树)，包含 insert, search, 和 startsWith 这三个操作。

示例:

Trie trie = new Trie();

trie.insert(“apple”);
trie.search(“apple”); // 返回 true
trie.search(“app”); // 返回 false
trie.startsWith(“app”); // 返回 true
trie.insert(“app”);
trie.search(“app”); // 返回 true
说明:

你可以假设所有的输入都是由小写字母 a-z 构成的。
保证所有输入均为非空字符串。

思路

建立一个27叉树，每一个节点包含‘a’-'z’26个字母的子节点和一个‘flag’结点用来判断到这里结束时是不是一个已插入的单词。
insert过程：便利每一个字母在树结构中传递，如果没有则新建，到最后一个字母时，在那个节点中插入键flag用来记录这是一个已经插入的单词。
search过程，按照给的单词遍历，一层层深入树，如果能遍历到最后一个字母，判断此时的node是否包含flag键，如果包含说明可以搜到。
startwith过程，只要能遍历完输入的单词，则说明有从这个单词startwith的。

代码

    class Trie:
        
     
        def __init__(self):
            """
            Initialize your data structure here.
            """
            self.root = {}
            
     
        def insert(self, word):
            """
            Inserts a word into the trie.
            :type word: str
            :rtype: void
            """
            node = self.root
            for c in word:
                if  c not in node:
                    node[c] = {}
                node = node[c]              
            node['flag'] = True
     
        def search(self, word):
            """
            Returns if the word is in the trie.
            :type word: str
            :rtype: bool
            """
            node = self.root
            for c in word:
                if not c in node:
                    return False
                node = node[c]                
            # Doesn't end here
            if 'flag'  not in node:
                return False            
            return True
     
        def startsWith(self, prefix):
            """
            Returns if there is any word in the trie that starts with the given prefix.
            :type prefix: str
            :rtype: bool
            """
            node = self.root
            for c in prefix:
                if not c in node:
                    return False
                node = node[c]    
            return True

     Your Trie object will be instantiated and called as such:
     obj = Trie()
     obj.insert(word)
     param_2 = obj.search(word)
     param_3 = obj.startsWith(prefix)
`