TrieTree

class TrieTree
{
public:
	//定义trie树节点，26个字符是定义在分支上。
	struct Node
	{
		int across;
		int end;
		shared_ptr<Node> nexts[26];
		Node() :across(0), end(0) {}
	};
	typedef shared_ptr<Node> NodePtr;
private:
	NodePtr root;

public:
	TrieTree() :root(make_shared<Node>()) {}
	/*插入：经过节点across+1，根节点除外*/
	void insert(string str)
	{
		if (str.empty()) return;
		NodePtr p = root;
		for (char ch:str)
		{
			int i = ch - 'a';
			if (p->nexts[i] == nullptr)//如果为空就创建节点
				p->nexts[i] = make_shared<Node>();
			
			p = p->nexts[i];
			p->across++;
		}
		p->end++;
	}

	int find(string str)
	{
		if (str.empty()) 
			return 0;
		NodePtr p = root;
		for (char ch : str)
		{
			if (p->nexts[ch - 'a'] == nullptr)
				return 0;
			else
				p = p->nexts[ch - 'a'];
		}
		return p->end;
	}

	void del(string str)
	{
		if (find(str) > 0)
		{
			NodePtr p = root;
			for (char ch : str)
			{
				p = p->nexts[ch - 'a'];
				if (--p->across == 0)
				{//说明只存在一次，删掉挂载的分支。
					p->nexts[ch - 'a'] = nullptr;
					return;
				}
			}
		}
	}
	int prefixNum(string str)
	{
		if (str.empty())
			return 0;
		NodePtr p = root;
		for (char ch : str)
		{
			if (p->nexts[ch - 'a'] == nullptr)
				return 0;
			p = p->nexts[ch - 'a'];
		}
		return p->across;
	}
};

用于词频统计，最长公共前缀。

struct Node {
    Node* next[26];
    int across;
    Node() :across(0) {
        memset(next, 0, sizeof(next));
    }
};

Node* root = new Node;

void insert(string& s) {
    Node* p = root;
    for (char& ch : s) {
        if (p->next[ch - 'a'] == NULL)
            p->next[ch - 'a'] = new Node;
        p = p->next[ch - 'a'];
        p->across++;
    }
}
int query(string& s) {
    Node* p = root;
    for (char& ch : s) {
        if (p->next[ch - 'a'] == NULL)
            return 0;
        p = p->next[ch - 'a'];
    }
    return p->across;
}
void del(Node* p) {
    for (int i = 0; i < 26; i++) {
        if (p->next[i]) del(p->next[i]);
    }
    free(p);
}

01字典树，计算整数x与数组中哪个值疑惑值最大或最小

struct Node {
	Node* next[2];
	int val;
	Node() {
		memset(next, 0, sizeof(next));
	}
};
Node* root = new Node;
void insert(int num) {
	Node* p = root;
	for (int i = 31; i >= 0; i--) {
		int d = ((num >> i) & 1);
		if (p->next[d] == NULL)
			p->next[d] = new Node;
		p = p->next[d];
	}
	p->val = num;
}
//计算最大值
int query(int x) {
	Node* p = root;
	for (int i = 31; i >= 0; i--) {
		int d = ((x >> i) & 1);
		if (p->next[d ^ 1])//贪心算法，优先走和x当前位不同的分支
			p = p->next[d ^ 1];
		else
			p = p->next[d];
	}
	return p->val;
}
//计算最小值
int query(int x) {
	Node* p = root;
	for (int i = 31; i >= 0; i--) {
		int d = ((x >> i) & 1);
		if (p->next[d])//贪心算法，优先走和x当前位相同的分支
			p = p->next[d];
		else
			p = p->next[d ^ 1];
	}
	return p->val;
}