Trie in C++

问题背景：
假设数据库中存有搜索词条和对应的搜索频度， 当用户输入某一串字符（不区分大小写）时， 需要输出以输入为前缀的若干搜索频度最大的词条。
下面是基于Trie的算法实现。 基于Trie的实现的好处是查询效率高， 支持动态查询（能快速更新数据库）。

C++ 源代码：

#include <iostream>
#include <cstring>
#include <string>
#include <cctype>
#include <queue>
#include <utility>
using namespace std;

const int n_ascii = 256;

struct trie_node {
    trie_node* ptrs[n_ascii];
    int freq;
    trie_node (int f = 0) : freq(f) {
        memset(ptrs, 0, sizeof(ptrs));
    }
};

class trie {
private:
    trie_node* root;
    
public:
    trie() : root(new trie_node()) {}
    ~trie() { release(root); }
    
    void insert(const string& word, int freq) {
        trie_node* prev = root;
        for (auto iter = word.begin(); iter != word.end(); ++iter) {
            int ch = *iter;
            trie_node* node = prev->ptrs[ch];
            if (!node) {
                prev->ptrs[ch] = node = new trie_node(); 
            }
            prev = node;
        }
        prev->freq = freq;
    }

    typedef pair<trie_node*, string> search_result_type;
    inline const vector<search_result_type> search(string prefix, bool case_sensitive = false) {
        if (case_sensitive) {
            return search_case_sensitive(prefix);    
        } else {
            return search_case_insensitive(prefix);
        }
    }
    
    const vector<search_result_type> search_case_sensitive(string prefix) const {
        trie_node* curr = root;
        for (auto iter = prefix.begin(); iter != prefix.end(); ++iter) {
            int ch = *iter;
            if (curr) curr = curr->ptrs[ch];
            else break;
        }
        vector<search_result_type> tmp;
        if (curr) tmp.push_back(make_pair(curr, prefix));
        return tmp;
    }

    inline const vector<search_result_type> search_case_insensitive(string prefix) const {
        vector<search_result_type> search_result;
        string prefix2(prefix);
        aux_search(root, prefix, 0, prefix2, search_result);
        return search_result;
    }
    
private:
    trie(const trie& t);
    const trie& operator=(const trie& t);

    void aux_search(const trie_node* pnode, const string& word, const int i, 
        string& prefix, vector<search_result_type>& search_result) const {
        if (i == word.size()) {
            search_result.push_back(
                make_pair(const_cast<trie_node*>(pnode), prefix));
        } 
        else if (pnode) {
            prefix[i] = word[i];
            aux_search(pnode->ptrs[word[i]], word, i+1, prefix, search_result);
            
            int ch = word[i];
            if (isupper(ch)) ch = tolower(ch);
            else if (islower(ch)) ch = toupper(ch);
            else ch = 0;
            if (ch) {
                prefix[i] = ch;
                aux_search(pnode->ptrs[ch], word, i+1, prefix, search_result);
            }
        }
    }
    
    void release(trie_node * root) {
        if (root) {
            for (int i = 0; i < n_ascii; i++) {
                release(root->ptrs[i]);
            }
            delete root;
        }
    }
};


string trim_head(const string& str) {
    auto pos = str.find_first_not_of(" \t");
    if (pos == string::npos) 
        return str;
    return str.substr(pos);
}

string trim_tail(const string& str) {
    auto pos = str.find_last_not_of(" \t");
    if (pos == string::npos)
        return str;
    return str.substr(0, pos+1);
}

typedef pair<string, int> value_type;
struct my_comp {
    bool operator()(const value_type& v1, const value_type& v2) const {
        if (v1.second != v2.second) {
            return v1.second > v2.second;
        }
        else return v1.first < v2.first;
    }
} comp_obj;
priority_queue<value_type, vector<value_type>, my_comp> priq;
int max_heap_size = 0;

void push_heap(const value_type& v) {
    if (priq.size() < max_heap_size) {
        priq.push(v);
    } else if (comp_obj(v, priq.top())) {
        priq.pop();
        priq.push(v);
    }
}

bool is_leaf(const trie_node* pnode) {
    if (pnode) {
        for (int i = 0; i < n_ascii; i++) {
            if (pnode->ptrs[i] != 0) return false;
        }
        return true;
    }
    return false;
}

bool is_valid_freq(const trie_node* pnode) {
    if (pnode) {
        return pnode->freq != 0;
    }
    return false;
}

void traverse(const trie_node* pnode, const string& prefix) {
    if (pnode) {
        if (is_valid_freq(pnode) || is_leaf(pnode)) 
            push_heap(make_pair(prefix, pnode->freq));
        for (int i = 0; i < n_ascii; i++) {
            if (pnode->ptrs[i]) {
                string tmp_str(prefix);
                traverse(pnode->ptrs[i], tmp_str.append(1, (char)i));
            }
        }
    }
}

void list_top_n(const trie& tr, const string& prefix, int n) {
    auto results = tr.search_case_insensitive(prefix);
    max_heap_size = n;
    for (auto result : results) {
        traverse(result.first, result.second);
    }
    
    vector<value_type> items;
    int lim = priq.size();
    for (int i = 0; i < lim; i++) {
        items.push_back(priq.top());
        priq.pop();
    }

    if (lim) {
        for (auto iter = items.rbegin(); iter != items.rend(); ++iter) {
            cout << iter->first << ' ' << iter->second << endl;
        }
    } else {
        cout << "not found !!!" << endl;
    }
}

int main() {
    trie tr; 
    string line;
    while (getline(cin, line)) {
        string words;
        auto iter = line.begin();
        for (; iter != line.end(); ++iter) {
            if (!isdigit(*iter)) {
                words.append(1, (char)(*iter));
            } else break;
        }
        if (isdigit(*iter)) {
            words = trim_tail(words);
            tr.insert(words, atoi(&(*iter)));
        } else break;
    }
    
    string prefix;
    while (getline(cin, prefix)) {
        cout << prefix << " : "<< endl;
        prefix = trim_head(prefix);
        list_top_n(tr, prefix, 10);
        cout << endl;
    }
    return 0;
}

测试：

输入：

Baidu   100
Google  100
Google Map  150
Google Play 200
gfsoso  100
google  250
Go 50

G

 

输出：

G : 
google 250
Google Play 200
Google Map 150
Google 100
gfsoso 100
Go 50