字典树？我直接刷爆

最新推荐文章于 2024-07-19 19:11:19 发布
最新推荐文章于 2024-07-19 19:11:19 发布
阅读量69 收藏
点赞数 1
文章标签： 算法 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liangxigua/article/details/130050300
版权

csdn

字典树（Trie）

数据结构简介…

💻Java中的字典树结构：
java代码

💻Python中的字典树结构：
python

高频面试题

1.实现 Trie (前缀树)

🚀题目链接：LeetCode208.实现 Trie (前缀树)

题目：

Trie（发音类似 “try”）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。
请你实现 Trie 类：

  • Trie() 初始化前缀树对象。
  • void insert(String word) 向前缀树中插入字符串 word 。
  • boolean search(String word) 如果字符串 word 在前缀树中，返回 true（即，在检索之前已经插入）；否则，返回 false 。
  • boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ，返回 true ；否则，返回 false 。

示例：

输入
["Trie", "insert", "search", "search", "startsWith", "insert", "search"]
[[], ["apple"], ["apple"], ["app"], ["app"], ["app"], ["app"]]
输出
[null, null, true, false, true, null, true]

解释
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

🍬C++ AC代码：

//  字典树节点定义：
class TrieNode {
public:
    char val;
    bool isWord = false;
    TrieNode* children[26] = {nullptr};

    TrieNode() {}

    TrieNode(char c) {
        TrieNode* node = new TrieNode();
        node->val = c;
    }
};

class Trie {
private:
    TrieNode* root;

public:
    Trie() {
        root = new TrieNode();
        root->val = ' ';
    }
    
    void insert(string word) {
        TrieNode* ws = root;
        for (int i = 0; i < word.length(); i++) {
            char c = word[i];
            if (ws->children[c - 'a'] == nullptr)
                ws->children[c - 'a'] = new TrieNode(c);
            ws = ws->children[c - 'a'];
        }
        ws->isWord = true;
    }
    
    bool search(string word) {
        TrieNode* ws = root;
        for (int i = 0; i < word.length(); i++) {
            char c = word[i];
            if (ws->children[c - 'a'] == nullptr)
                return false;
            ws = ws->children[c - 'a'];
        }
        return ws->isWord;
    }
    
    bool startsWith(string prefix) {
        TrieNode* ws = root;
        for (int i = 0; i < prefix.length(); i++) {
            char c = prefix[i];
            if (ws->children[c - 'a'] == nullptr)
                return false;
            ws = ws->children[c - 'a'];
        }
        return true;
    }
};

☕Java AC代码：

class Trie {

    private TrieNode root;

    public Trie() {
        root = new TrieNode();
        root.val = ' ';
    }
    
    public void insert(String word) {
        TrieNode ws = root;
        for (int i = 0; i < word.length(); i++) {
            char c = word.charAt(i);
            if (ws.children[c - 'a'] == null)
                ws.children[c - 'a'] = new TrieNode(c);
            ws = ws.children[c - 'a'];
        }
        ws.isWord = true;
    }
    
    public boolean search(String word) {
        TrieNode ws = root;
        for (int i = 0; i < word.length(); i++) {
            char c = word.charAt(i);
            if (ws.children[c - 'a'] == null)
                return false;
            ws = ws.children[c - 'a'];
        }
        return ws.isWord;
    }
    
    public boolean startsWith(String prefix) {
        TrieNode ws = root;
        for (int i = 0; i < prefix.length(); i++) {
            char c = prefix.charAt(i);
            if (ws.children[c - 'a'] == null)
                return false;
            ws = ws.children[c - 'a'];
        }
        return true;
    }
}

//  字典树节点定义：
class TrieNode {

    public char val;
    public boolean isWord;
    public TrieNode[] children = new TrieNode[26];

    public TrieNode() {}

    TrieNode(char c) {
        TrieNode node = new TrieNode();
        node.val = c;
    }
}

🍦Python AC代码：

class Trie(object):

    def __init__(self):
        self.root = {}
        self.end_of_word = "#"

    def insert(self, word):
        node = self.root
        for char in word:
        	# 如果key存在则返回value，不存在则构建一个新的key-value再返回
            node = node.setdefault(char, {})
        node[self.end_of_word] = self.end_of_word


    def search(self, word):
        node = self.root
        for char in word:
            if char not in node:
                return False
            node = node[char]
        return self.end_of_word in node


    def startsWith(self, prefix):
        node = self.root
        for char in prefix:
            if char not in node:
                return False
            node = node[char]
        return True

✨Tips：

  • ⭐Python中可以使用字典dictionary来代替我们自己定义的字典树结构，key是字符char，value是一个新的字典{}或者结束字符#。

2. 单词搜索 II

🚀题目链接：LeetCode212. 单词搜索 II

题目：
给定一个 m x n 二维字符网格 board 和一个单词（字符串）列表 words， 返回所有二维网格上的单词 。
单词必须按照字母顺序，通过 相邻的单元格 内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母在一个单词中不允许被重复使用。

示例 1：
1

输入：
board = [["o","a","a","n"],["e","t","a","e"],["i","h","k","r"],["i","f","l","v"]], 
words = ["oath","pea","eat","rain"]
输出：["eat","oath"]

示例 2：
2

输入：board = [["a","b"],["c","d"]], words = ["abcb"]
输出：[]

🍬C++ AC代码：

//  字典树节点定义：
struct Trie {
	Trie* child[26];
	string word = "";
	Trie() {
		for (int i = 0; i < 26; i++)
			child[i] = nullptr;
	}
};

class Solution {
public:
	// set保存结果用来去重
    set<string> temp_res;
    int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    vector<string> findWords(vector<vector<char>>& board, vector<string>& words) {
        vector<string> res;
        Trie* trie = new Trie();
        // 将单词加入字典树
        for (int i = 0; i < words.size(); i++) {
            Trie* cur = trie;
			for (int j = 0; j < words[i].size(); j++) {
				if (cur->child[words[i][j] - 'a'] == nullptr)
					cur->child[words[i][j] - 'a'] = new Trie();
				cur = cur->child[words[i][j] - 'a'];
			}
			cur->word = words[i];
        }
        int m = board.size(), n = board[0].size();
        // 对二维网格的每一个位置进行dfs搜索
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                dfs(board, i, j, trie);
            }
        }
        // set转换成vector返回
        res.assign(temp_res.begin(), temp_res.end());
        return res;
    }

    void dfs(vector<vector<char>>& board, int x, int y, Trie* trie) {
        // 超出网格边界直接返回
        if (x < 0 || x >= board.size() || y < 0 || y >= board[0].size()) return;
        char c = board[x][y];
        // 检查是否访问过该位置和单词是否在字典树中存在
        if (c == '*' || trie->child[c-'a']==nullptr) return;
		trie = trie->child[c - 'a'];
		// 在字典树中存在当前dfs访问路径构成的单词
		if (trie->word != "") {
			temp_res.insert(trie->word);
			trie->word = "";
		}
		// 标记该位置已经访问
        board[x][y] = '*';
        // 递归访问上下左右四个方向
        for (int i = 0; i < 4; i++)
            dfs(board, x + dirs[i][0], y + dirs[i][1], trie);
        // 回溯
        board[x][y] = c;
    }
};

✨Tips：

  • ⭐C++代码调用上面一题已经写好的字典树中的方法提交上去会超时，这里将字典树的search()和startWith()方法写在dfs中，避免每次dfs调用这两个方法造成不必要的时间开销。
  • ⭐dfs()函数向上下左右四个方向递归访问时，我们需要判断访问的位置之前是否已经访问过了，可以使用一个额外的bool类型的二维数组visited[][]标记走过的位置，更好的办法是向上面的代码这样，直接修改board数组，将访问过的位置置为"*"。
  • ⭐经过测试使用额外数组标记的方式提交会超时，而下面的Java代码使用额外数组却能通过😂~

☕Java AC代码：

class Solution {

    // set用来存保存结果并去重
    Set<String> res = new HashSet<>();
    // 代表上下左右四个方向，dfs中会用到
    int[][] dirs = new int[][]{{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    public List<String> findWords(char[][] board, String[] words) {
        Trie trie = new Trie();
        // 将单词加入到字典树中
        for (String word : words)
            trie.insert(word);
        int m = board.length, n = board[0].length;
        boolean[][] visited = new boolean[m][n];
        // 对二维网格的每一个位置进行dfs搜索
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                dfs(board, visited, "", i, j, trie);
            }
        }
        return new ArrayList<String>(res);
    }

    public void dfs(char[][] board, boolean[][] visited, String str, int x, int y, Trie trie) {
        // 超出网格边界直接返回
        if (x < 0 || x >= board.length || y < 0 || y >= board[0].length) return;
        // 访问到了之前访问过的位置，直接返回
        if (visited[x][y]) return;
        str += board[x][y];
        // 检查单词是否在字典树中存在
        if (!trie.startsWith(str)) return;
        if (trie.search(str)) res.add(str);
        visited[x][y] = true;
        // 递归访问上下左右四个方向
        for (int i = 0; i < 4; i++)
            dfs(board, visited, str, x + dirs[i][0], y + dirs[i][1], trie);
        // 回溯
        visited[x][y] = false;
    }
}

✨Tips：

  • ⭐Java代码要用到上面一题的字典树结构，这里只展示本题的核心代码，提交代码时记得复制一份字典树代码在本题后面😎。
  • ⭐Java代码超时的判定比较宽松，只要用了字典树就不会超时，不做额外的优化也可以通过。

🍦Python AC代码：

# 方向数组，用来dfs访问上下左右四个位置
dx = [-1, 1, 0, 0]
dy = [0, 0, -1, 1]

# 字典树单词结束标志
END_OF_WORD = "#"

class Solution(object):
    def findWords(self, board, words):
        if not board or not board[0]: return []
        if not words: return []
		# set保存结果同时去重
        self.result = set()
		# 使用python中的dict字典创建字典树
        root = collections.defaultdict()
        # 将单词加入字典树
        for word in words:
            node = root
            for char in word:
                node = node.setdefault(char, collections.defaultdict())
            node[END_OF_WORD] = END_OF_WORD
        self.m, self.n = len(board), len(board[0])
		# 遍历网格中的每个位置，调用dfs搜索单词
        for i in xrange(self.m):
            for j in xrange(self.n):
                if board[i][j] in root:
                    self._dfs(board, i, j, "", root)
		# set转换成list返回
        return list(self.result)

    def _dfs(self, board, i, j, cur_word, cur_dict):
		# 获取当前字母在字典树中的位置
        cur_word += board[i][j]
        cur_dict = cur_dict[board[i][j]]
		# 当前字符是结束字符，说明找到了单词列表中的单词
        if END_OF_WORD in cur_dict:
            self.result.add(cur_word)
		# 标记当前位置已经访问过
        tmp, board[i][j] = board[i][j], '@'
        # 递归访问上下左右四个位置
        for k in xrange(4):
            x, y = i + dx[k], j + dy[k]
            # 判断访问的位置是否在网格内以及之前是否访问过
            if 0 <= x < self.m and 0 <= y < self.n and board[x][y] != '@' and board[x][y] in cur_dict:
                self._dfs(board, x, y, cur_word, cur_dict)
        # 回溯
        board[i][j] = tmp

✨Tips：

  • ⭐Python的代码执行时间比较长，我们需要标记已经访问过的位置，和C++代码的方式一样，直接修改原数组board即可，不用借助额外的标记数组，这里可以优化一下。

总结

┊回首向来萧瑟处，归去。也无风雨也无晴┊
-苏轼《定风波》-

footer
csdn

字典树（Trie）

数据结构简介…

💻Java中的字典树结构：
java代码

💻Python中的字典树结构：
python

高频面试题

1.实现 Trie (前缀树)

🚀题目链接：LeetCode208.实现 Trie (前缀树)

题目：

Trie（发音类似 “try”）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。
请你实现 Trie 类：

  • Trie() 初始化前缀树对象。
  • void insert(String word) 向前缀树中插入字符串 word 。
  • boolean search(String word) 如果字符串 word 在前缀树中，返回 true（即，在检索之前已经插入）；否则，返回 false 。
  • boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ，返回 true ；否则，返回 false 。

示例：

输入
["Trie", "insert", "search", "search", "startsWith", "insert", "search"]
[[], ["apple"], ["apple"], ["app"], ["app"], ["app"], ["app"]]
输出
[null, null, true, false, true, null, true]

解释
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

🍬C++ AC代码：

//  字典树节点定义：
class TrieNode {
public:
    char val;
    bool isWord = false;
    TrieNode* children[26] = {nullptr};

    TrieNode() {}

    TrieNode(char c) {
        TrieNode* node = new TrieNode();
        node->val = c;
    }
};

class Trie {
private:
    TrieNode* root;

public:
    Trie() {
        root = new TrieNode();
        root->val = ' ';
    }
    
    void insert(string word) {
        TrieNode* ws = root;
        for (int i = 0; i < word.length(); i++) {
            char c = word[i];
            if (ws->children[c - 'a'] == nullptr)
                ws->children[c - 'a'] = new TrieNode(c);
            ws = ws->children[c - 'a'];
        }
        ws->isWord = true;
    }
    
    bool search(string word) {
        TrieNode* ws = root;
        for (int i = 0; i < word.length(); i++) {
            char c = word[i];
            if (ws->children[c - 'a'] == nullptr)
                return false;
            ws = ws->children[c - 'a'];
        }
        return ws->isWord;
    }
    
    bool startsWith(string prefix) {
        TrieNode* ws = root;
        for (int i = 0; i < prefix.length(); i++) {
            char c = prefix[i];
            if (ws->children[c - 'a'] == nullptr)
                return false;
            ws = ws->children[c - 'a'];
        }
        return true;
    }
};

☕Java AC代码：

class Trie {

    private TrieNode root;

    public Trie() {
        root = new TrieNode();
        root.val = ' ';
    }
    
    public void insert(String word) {
        TrieNode ws = root;
        for (int i = 0; i < word.length(); i++) {
            char c = word.charAt(i);
            if (ws.children[c - 'a'] == null)
                ws.children[c - 'a'] = new TrieNode(c);
            ws = ws.children[c - 'a'];
        }
        ws.isWord = true;
    }
    
    public boolean search(String word) {
        TrieNode ws = root;
        for (int i = 0; i < word.length(); i++) {
            char c = word.charAt(i);
            if (ws.children[c - 'a'] == null)
                return false;
            ws = ws.children[c - 'a'];
        }
        return ws.isWord;
    }
    
    public boolean startsWith(String prefix) {
        TrieNode ws = root;
        for (int i = 0; i < prefix.length(); i++) {
            char c = prefix.charAt(i);
            if (ws.children[c - 'a'] == null)
                return false;
            ws = ws.children[c - 'a'];
        }
        return true;
    }
}

//  字典树节点定义：
class TrieNode {

    public char val;
    public boolean isWord;
    public TrieNode[] children = new TrieNode[26];

    public TrieNode() {}

    TrieNode(char c) {
        TrieNode node = new TrieNode();
        node.val = c;
    }
}

🍦Python AC代码：

class Trie(object):

    def __init__(self):
        self.root = {}
        self.end_of_word = "#"

    def insert(self, word):
        node = self.root
        for char in word:
        	# 如果key存在则返回value，不存在则构建一个新的key-value再返回
            node = node.setdefault(char, {})
        node[self.end_of_word] = self.end_of_word


    def search(self, word):
        node = self.root
        for char in word:
            if char not in node:
                return False
            node = node[char]
        return self.end_of_word in node


    def startsWith(self, prefix):
        node = self.root
        for char in prefix:
            if char not in node:
                return False
            node = node[char]
        return True

✨Tips：

  • ⭐Python中可以使用字典dictionary来代替我们自己定义的字典树结构，key是字符char，value是一个新的字典{}或者结束字符#。

2. 单词搜索 II

🚀题目链接：LeetCode212. 单词搜索 II

题目：
给定一个 m x n 二维字符网格 board 和一个单词（字符串）列表 words， 返回所有二维网格上的单词 。
单词必须按照字母顺序，通过 相邻的单元格 内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母在一个单词中不允许被重复使用。

示例 1：
1

输入：
board = [["o","a","a","n"],["e","t","a","e"],["i","h","k","r"],["i","f","l","v"]], 
words = ["oath","pea","eat","rain"]
输出：["eat","oath"]

示例 2：
2

输入：board = [["a","b"],["c","d"]], words = ["abcb"]
输出：[]

🍬C++ AC代码：

//  字典树节点定义：
struct Trie {
	Trie* child[26];
	string word = "";
	Trie() {
		for (int i = 0; i < 26; i++)
			child[i] = nullptr;
	}
};

class Solution {
public:
	// set保存结果用来去重
    set<string> temp_res;
    int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    vector<string> findWords(vector<vector<char>>& board, vector<string>& words) {
        vector<string> res;
        Trie* trie = new Trie();
        // 将单词加入字典树
        for (int i = 0; i < words.size(); i++) {
            Trie* cur = trie;
			for (int j = 0; j < words[i].size(); j++) {
				if (cur->child[words[i][j] - 'a'] == nullptr)
					cur->child[words[i][j] - 'a'] = new Trie();
				cur = cur->child[words[i][j] - 'a'];
			}
			cur->word = words[i];
        }
        int m = board.size(), n = board[0].size();
        // 对二维网格的每一个位置进行dfs搜索
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                dfs(board, i, j, trie);
            }
        }
        // set转换成vector返回
        res.assign(temp_res.begin(), temp_res.end());
        return res;
    }

    void dfs(vector<vector<char>>& board, int x, int y, Trie* trie) {
        // 超出网格边界直接返回
        if (x < 0 || x >= board.size() || y < 0 || y >= board[0].size()) return;
        char c = board[x][y];
        // 检查是否访问过该位置和单词是否在字典树中存在
        if (c == '*' || trie->child[c-'a']==nullptr) return;
		trie = trie->child[c - 'a'];
		// 在字典树中存在当前dfs访问路径构成的单词
		if (trie->word != "") {
			temp_res.insert(trie->word);
			trie->word = "";
		}
		// 标记该位置已经访问
        board[x][y] = '*';
        // 递归访问上下左右四个方向
        for (int i = 0; i < 4; i++)
            dfs(board, x + dirs[i][0], y + dirs[i][1], trie);
        // 回溯
        board[x][y] = c;
    }
};

✨Tips：

  • ⭐C++代码调用上面一题已经写好的字典树中的方法提交上去会超时，这里将字典树的search()和startWith()方法写在dfs中，避免每次dfs调用这两个方法造成不必要的时间开销。
  • ⭐dfs()函数向上下左右四个方向递归访问时，我们需要判断访问的位置之前是否已经访问过了，可以使用一个额外的bool类型的二维数组visited[][]标记走过的位置，更好的办法是向上面的代码这样，直接修改board数组，将访问过的位置置为"*"。
  • ⭐经过测试使用额外数组标记的方式提交会超时，而下面的Java代码使用额外数组却能通过😂~

☕Java AC代码：

class Solution {

    // set用来存保存结果并去重
    Set<String> res = new HashSet<>();
    // 代表上下左右四个方向，dfs中会用到
    int[][] dirs = new int[][]{{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    public List<String> findWords(char[][] board, String[] words) {
        Trie trie = new Trie();
        // 将单词加入到字典树中
        for (String word : words)
            trie.insert(word);
        int m = board.length, n = board[0].length;
        boolean[][] visited = new boolean[m][n];
        // 对二维网格的每一个位置进行dfs搜索
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                dfs(board, visited, "", i, j, trie);
            }
        }
        return new ArrayList<String>(res);
    }

    public void dfs(char[][] board, boolean[][] visited, String str, int x, int y, Trie trie) {
        // 超出网格边界直接返回
        if (x < 0 || x >= board.length || y < 0 || y >= board[0].length) return;
        // 访问到了之前访问过的位置，直接返回
        if (visited[x][y]) return;
        str += board[x][y];
        // 检查单词是否在字典树中存在
        if (!trie.startsWith(str)) return;
        if (trie.search(str)) res.add(str);
        visited[x][y] = true;
        // 递归访问上下左右四个方向
        for (int i = 0; i < 4; i++)
            dfs(board, visited, str, x + dirs[i][0], y + dirs[i][1], trie);
        // 回溯
        visited[x][y] = false;
    }
}

✨Tips：

  • ⭐Java代码要用到上面一题的字典树结构，这里只展示本题的核心代码，提交代码时记得复制一份字典树代码在本题后面😎。
  • ⭐Java代码超时的判定比较宽松，只要用了字典树就不会超时，不做额外的优化也可以通过。

🍦Python AC代码：

# 方向数组，用来dfs访问上下左右四个位置
dx = [-1, 1, 0, 0]
dy = [0, 0, -1, 1]

# 字典树单词结束标志
END_OF_WORD = "#"

class Solution(object):
    def findWords(self, board, words):
        if not board or not board[0]: return []
        if not words: return []
		# set保存结果同时去重
        self.result = set()
		# 使用python中的dict字典创建字典树
        root = collections.defaultdict()
        # 将单词加入字典树
        for word in words:
            node = root
            for char in word:
                node = node.setdefault(char, collections.defaultdict())
            node[END_OF_WORD] = END_OF_WORD
        self.m, self.n = len(board), len(board[0])
		# 遍历网格中的每个位置，调用dfs搜索单词
        for i in xrange(self.m):
            for j in xrange(self.n):
                if board[i][j] in root:
                    self._dfs(board, i, j, "", root)
		# set转换成list返回
        return list(self.result)

    def _dfs(self, board, i, j, cur_word, cur_dict):
		# 获取当前字母在字典树中的位置
        cur_word += board[i][j]
        cur_dict = cur_dict[board[i][j]]
		# 当前字符是结束字符，说明找到了单词列表中的单词
        if END_OF_WORD in cur_dict:
            self.result.add(cur_word)
		# 标记当前位置已经访问过
        tmp, board[i][j] = board[i][j], '@'
        # 递归访问上下左右四个位置
        for k in xrange(4):
            x, y = i + dx[k], j + dy[k]
            # 判断访问的位置是否在网格内以及之前是否访问过
            if 0 <= x < self.m and 0 <= y < self.n and board[x][y] != '@' and board[x][y] in cur_dict:
                self._dfs(board, x, y, cur_word, cur_dict)
        # 回溯
        board[i][j] = tmp

✨Tips：

  • ⭐Python的代码执行时间比较长，我们需要标记已经访问过的位置，和C++代码的方式一样，直接修改原数组board即可，不用借助额外的标记数组，这里可以优化一下。

总结

┊回首向来萧瑟处，归去。也无风雨也无晴┊
-苏轼《定风波》-

footer

liangxigua
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
acm 算法 字典树模板
05-29
ACM 算法字典树模板 在算法竞赛中，字典树（Trie）是一种常用的数据结构，用于解决字符串匹配问题。下面是字典树的基本概念和实现细节。 字典树的基本概念 字典树是一种树形数据结构，用于存储字符串集合。它的每...
Trie树_字典树(字符串排序)简介及实现
10-26
有时，我们会碰到对字符串的排序，若采用一些经典的排序算法，则时间复杂度一般为O(n*lgn)，但若采用Trie树，则时间复杂度仅为O(n)
python defaultdict tree_Python:defaultdict每个值都会更新
weixin_33967069的博客
02-09 131
我为一个愚蠢的问题工作了一个多小时，但我想不出解决办法。我用一个初始列表创建一个defaultdict(list)，并通过for循环更新这些列表。但是，每次我更新一个值，所有其他值都会用相同的值更新。有人能帮帮我吗？这是我的代码：from collections import defaultdictbase = ["coucou", "salut", "tchao"]initial_vector ...
Python中的defaultdict函数与Trie树
不知道起什么名字
12-02 544
dict() 对于普通的dict，key不存在就报错。 >>> a = dict() >>> a['k1'] = 1 >>> a {'k1': 1} >>> a['k2'] Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'k2' >>> from collection
python defaultdict tree,使用defaultdict的Python一线树。如何减少所需的参数数量？
weixin_30074929的博客
01-28 106
I'm using this gist's defaultdict one-line tree.def tree(): return defaultdict(tree)Currently, you must provide a separate [] for every node you want to add.ie:users = tree()users['harold']['username'...
python defaultdict 递归_Python递归树问题（添加元素或任意节点）
weixin_39778150的博客
12-08 170
我不得不解决学校使用A *的一个微不足道的问题(这不是我遇到的问题)，我想用树来存储探索节点所以当找到解决方案时，很容易找到从叶子到根的路径。Python递归树问题(添加元素或任意节点)Python中的树可以通过使用defaultdictionaries进行：def tree(): return defaultdict(tree)因此，例如：a=tree() is an empty treea[1...
python的前缀树（字典树）
qq_41967784的博客
11-02 824
python的前缀树字典树
码云最火爆开源项目 TOP 50，你都用过哪些？
热门推荐
04-24 1万+
前 20 名预览 排名软件排名软件 1zheng11AOSuite 2JFinal12Spiderman 3t-io13AG-Admin 4guns14renren-security 5hutool15jfinal-weixin 6mybatis-plus16webmagic 7NiceFish17ip2region 8easypoi18zbus 9roncoo-pay19xx...
字典树_字典树_
10-03
字典树，也被称为Trie或前缀树，是一种用于高效存储和检索字符串的数据结构。在计算机科学中，字典树常被用于实现自动补全、关键词搜索、IP路由等功能，因为它能快速查找以特定前缀开头的所有字符串。下面将详细介绍...
DT_字典树前缀推荐_源码
10-04
在IT领域，字典树（Trie，也称为Prefix Tree或Patricia Tree）是一种非常重要的数据结构，尤其在实现高效前缀匹配和推荐系统时。本文将深入探讨字典树的概念、工作原理以及如何利用它来实现“前缀推荐”功能。 首先...
在Python中使用defaultdict初始化字典以及应用方法
12-24
Python中可以使用collections中的defaultdict类实现创建进行统一初始化的字典。这里总结两种常用一点的初始化方式，分别是初始化为list和int。 初始化为list示范代码： #!/usr/bin/python from collectionsimport defaultdict s = [('yellow',1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)] d =defaultdict(list) for k,v in s: d[k].append(v) print(d.items() 运行结果如下： E
字典树_英汉词典
05-19
字典树，文档，增删改，排序，输出字典所有单词及意思
defaultdict的妙用
Great haste makes great waste
05-06 1853
python中的内置库collections中有个defaultdict，这个具体的用法就不说了，资料很多，确实好用。 但是想在嵌套的dict中使用defaultdict就比较麻烦了，正好在网上看到一个相关的， 使用递归解决了这个问题，非常的妙：from collections import defaultdictdef tree(): return defaultdict(tree)使用
【18】输出字符菱形
2301_78786609的博客
07-19 287
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Held-Karp算法的C++代码
最新发布
m0_61862494的博客
07-19 108
Held-Karp算法是动态规划的一种应用，用于解决旅行商问题 (TSP)。该算法通过记录部分路径的最小成本来避免重复计算，从而有效地降低计算复杂度。Held-Karp算法使用一个状态压缩动态规划表。表示从起点出发，访问过所有由。表示的集合中的节点，并以节点。结束的最小路径长度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 236
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
常见的排序算法，复杂度
m0_61544805的博客
07-16 517
稳定 / 非稳定排序：两个相等的数 排序前后 相对位置不变。 插入排序（希尔排序）： 每一趟将一个待排序记录，按其关键字的大小插入到已排好序的一组记录的适当位置上，直到所有待排序记录全部插入为止。稳定，O(n)，O(1)。 把记录按下标增量（模）分组，对每组进行直接插入排序，每次排序后减小增量，当增量减至 1 时排序完毕。不稳定，不知道（有个实验结论），O(1)。 冒泡排序： 比较相邻的元素，如果第一个比第二个大就进行交换，对每一对相邻元素做同样的工作。稳定，O(n)，O(1)。 选择
代码随想录学习 54day 图论 A star算法
qq_40445763的博客
07-17 445
【代码】代码随想录学习 54day 图论 A star算法。
构建字典树：从KMP到ASCII
"这篇资料主要介绍了字典树（Trie）的构建过程，并结合实例解释了如何通过插入单词来逐步构建字典树。同时提到了KMP算法，但并未详细介绍，主要焦点在于字典树的构造。" 在计算机科学中，字典树是一种高效的数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值