trie树

最新推荐文章于 2025-03-09 10:32:18 发布

转载最新推荐文章于 2025-03-09 10:32:18 发布 · 329 阅读

acm入门专栏收录该内容

27 篇文章

订阅专栏

（1）概述

trie树，又称字典树或前缀树，是一种用于快速检索的多叉树结构，如英文字母的字典树是26叉树，数字的字典树是10叉树。

（2）构建

如果我们有and，as，at，cn，com这些关键词，如何构建trie树呢？

从图中，我们可以看出以下几点特性：

1.所有节点都包含一个字符（有些地方根节点不保存字符，其实都一样）

2.从根到某一节点，经过路径上的字符连接起来，就是该节点对应的字符串

3.各个节点的公共前缀都作为一个节点来保存

（3）插入数据

首先先定义节点，因为共26个字母，所以为26叉树，所以申请26个Node类型的数组，通过下标来判断是哪个字符（如下标0代表‘a’，下标2代表‘c’，如果不为空，则说明就是该字母）

	private class Node
	{
		private Node[] nodes;
		private boolean isEnd;//判断是否是一个单词的结尾
		
		public Node() 
		{
			this.isEnd = false;
			this.nodes = new Node[26];
		}
		
	}

插入一个字符串的时候，先判断第一个字符是否在trie树种存在，如果存在，则找到该节点指向的节点，然后在查找第二个字符；如果不存在，则创建新的节点

public class Tire 
{
	private Node root;
	
	
	public Tire() 
	{
		this.root = new Node();
	}


	public void insert(String str)
	{
		Node t = root;
		
		for(int i=0; i<str.length(); i++)
		{
			if(t.nodes[str.charAt(i)-'a'] == null)
			{
				t.nodes[str.charAt(i)-'a'] = new Node();
			}
			t = t.nodes[str.charAt(i)-'a'];
		}
		t.isEnd = true;//一个字符串结束之后，用来标记是一个单词
	}
}

例：当插入ab和at时，实际的存储结构为：

（4）查找数据

循环变量要查找的字符串的各个字符，在trie树种查找，找到后查找下一个字符，并且将指向的节点下移，直到字符串变量完毕，然后判断一下是否是一个单词的结尾（通过插入时候设置isEnd），如果是，则说明能够找到，否则其中任意一个字符找不到，则说明不存在

	public boolean find(String str)
	{
		Node t = root;
		
		for(int i=0; i<str.length()&&t!=null; i++)
		{
			if(t.nodes[str.charAt(i)-'a'] == null)//有一个字符找不到，则说明不存在
				return false;
			
			t = t.nodes[str.charAt(i)-'a'];
		}
		return t.isEnd;//如果是一个单词的结尾，则说明找到了；否则说明只是某个单词的前缀
	}

（5）trie树应用

1.字符串检索

事先将已知的一些字符串（如字典）相关信息保存到trie树种，查找另一些未知字符串是否出现过。（即trie树的查找功能）

2.词频统计

可能有人会说了，词频统计可以使用hash来做，但是如果空间有限，就不能这么做了。我们这里可以使用trie树来压缩空间，因为所有公共前缀都是用一个节点来保存的

方法：在Node中添加一个count字段，用来统计单词出现的次数（必须与isEnd一起使用，也就是单词的结束的时候再count++，否则就相当于前缀出现的次数）

在Node添加新的属性

	private class Node
	{
		private Node[] nodes;
		private boolean isEnd;
		private int count;//统计单词出现次数
		
		public Node() 
		{
			this.isEnd = false;
			this.count = 0;
			this.nodes = new Node[26];
		}
		
	}

修改插入时的代码

public void insert(String str)
	{
		Node t = root;
		
		for(int i=0; i<str.length(); i++)
		{
			if(t.nodes[str.charAt(i)-'a'] == null)
			{
				t.nodes[str.charAt(i)-'a'] = new Node();
			}
			t = t.nodes[str.charAt(i)-'a'];
		}
		t.isEnd = true;
		t.count++;
	}

查找出要统计次数的字符串在trie树种的最后一个节点

	public Node findCount(String str)
	{
		Node t = root;
		
		for(int i=0; i<str.length()&&t!=null; i++)
		{
			if(t.nodes[str.charAt(i)-'a'] == null)//如果其中一个字符找不到，则说明该字符串不存在
				return null;
			
			t = t.nodes[str.charAt(i)-'a'];
		}
		
		if(t.isEnd)  //如果是一个单词的结尾
			return t;
		else
			return null;//如果不是结尾，则说明只是前缀
	}

测试：

		Tire tire = new Tire();
		String[] str = {"a", "to", "tea", "ted", "ten","ten", "i", "in", "inn"};
		
		for(String s:str)
			tire.insert(s);

		if(tire.findCount("ten") != null)
			System.out.println(tire.findCount("ten").count);
		else
			System.out.println("this string does not exist in trie tree");

结果为：

3.前缀匹配

统计具有特定公共前缀的单词有多少个，如查找{"a", "to", "tea", "ted", "ten","ten", "i", "in", "inn"}中具有公共前缀te的单词有多少个。

先找到存储前缀最后一个字符的节点，则其所有子树的单词都是以te为前缀的，然后分治统计其各个子节点：

1>如果节点p为null，则返回0

2>否则返回26个子树所有单词数量并相加（注意，当前节点可能就是一个单词，所以还要加上当前节点的单词）

	public int  prefix(String str)
	{
		Node cur = root;
		
		for(int i=0; i<str.length(); i++)               //用来找到指向所求前缀的最后一个字符的节点
		{
			if(cur.nodes[str.charAt(i)-'a'] == null)
				return 0;
			cur = cur.nodes[str.charAt(i)-'a'];
		} 
		
		return prefix(cur);
	}
	
	private int prefix(Node p) 
	{
		if(p == null)              //如果为null，直接返回0
			return 0;
		
		else
		{
			int count = 0;

			for (int i = 0; i < p.nodes.length; i++) 
			{
				count += prefix(p.nodes[i]);       //将所有子树的单词相加
			}
			if (p.isEnd)                               //因为该节点本身就是个单词，所以再加上
				count += p.count;
			return count;
		}
	}

测试：

	public static void main(String[] args) {
		String[] str = {"a", "a","t","to", "tea", "ted", "ten","ten", "i", "in", "inn"};
		Trie trie = new Trie();
		for(String s:str)
			trie.insert(s);

		System.out.println(trie.prefix("te"));
	}

结果为：

4.字符串字典顺序排序

在节点中定义一个字段存储单词，如果只是前缀，那么为null。建立trie树，先序遍历即可。

定义节点：

	class Node
	{
		private boolean isEnd;
		private Node [] nodes = null;
		private int count;
		private String word;      //保存单词，如果为前缀则为null
		
		public Node()
		{
			super();
			this.isEnd = false;
			this.nodes = new Node[26];
			this.count = 0;
			this.word = null;
		}
	}

在一个单词插入结束时，将单词保存

	public void insert(String str)
	{
		Node cur = root;
		
		for(int i=0; i<str.length(); i++)
		{
			if(cur.nodes[str.charAt(i)-'a'] == null)
			{
				cur.nodes[str.charAt(i)-'a'] = new Node();
			}
			cur = cur.nodes[str.charAt(i)-'a'];
		}
		
		cur.isEnd = true;
		cur.count++;
		cur.word = str;  //单词结束则保存
	}

先序遍历

	public void preTraverse(Node p)
	{
		if(p.isEnd)             //如果是一个单词的结尾
		{
			for(int i=0; i<p.count; i++)   //单词可能有重复，全部输出
				System.out.print(p.word + " ");
		}
		
		for(int i=0; i<p.nodes.length; i++)
		{
			if(p.nodes[i] != null)           //如果为null，则说明不存在，就不用递归了
				preTraverse(p.nodes[i]);
		}
	}

测试：

	public static void main(String[] args) {
		String[] str = {"a", "a","t","to", "tea", "ted", "ten","ten", "i", "in", "inn"};
		Trie trie = new Trie();
		for(String s:str)
			trie.insert(s);

		trie.preTraverse(trie.root);
	}

结果为：