TrieTree

#pragma once
#include <vector>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <hash_map>
using namespace stdext;
using namespace std;
//#define _TRIETREE_SET
class TrieTree
{
#ifdef _TRIETREE_SET
struct TrieNode
{
bool isWord;
char value;
set<TrieNode *> branch;
TrieNode(char _value):value(_value),isWord(false)
{
}
bool operator<(const TrieNode& rhs)const
{
return this->value < rhs.value;
}
};
#else
struct TrieNode
{
//typedef map<char,TrieNode *> MapType;
typedef hash_map<char,TrieNode *> MapType;
bool isWord;
char value;
MapType branch;
//map<char,TrieNode *> branch;
TrieNode(char _value):value(_value),isWord(false){}
bool operator<(const TrieNode& rhs)
{
return this->value < rhs.value;
}
};
#endif
public:
TrieTree(void);
~TrieTree(void);
void Insert(string &str);
void LevelOrder()const;
bool Contain(string &str)const;
void PreOrder()const;
void PostOrder()const;
bool PrefixCon(string &str)const;
private:
void Insert(TrieNode *,string &str);
void InsertNoRec(string &str);
void LevelOrder(TrieNode *)const;
bool Contain(string &str,int n)const;
void PreOrder(TrieNode *)const;
void PostOrder(TrieNode *)const;
bool PrefixCon(TrieNode *,string &str)const;
private:
TrieNode *root;

};

#include "TrieTree.h"
#include <queue>
#include <iostream>
#include <functional>




TrieTree::TrieTree(void)
:root(new TrieNode('&'))
{
}




TrieTree::~TrieTree(void)
{
}


void TrieTree::Insert(string &str)
{
InsertNoRec(str);
}


void TrieTree::Insert(TrieNode *t,string &str)
{

}


void TrieTree::InsertNoRec(string &str)
{
TrieNode *t = root;
    auto iter = str.begin();
auto it = t->branch.end();
#ifdef _TRIETREE_SET
while(iter != str.end())
{
it = find_if(t->branch.begin(),t->branch.end(),[&iter](TrieNode *node)->bool{return node->value == *iter;});
        if(it == t->branch.end())
{
TrieNode *node = new TrieNode(*iter);
t->branch.insert(node);
t = node;
}
else
{
t = *it;
}
++iter;
}
#else
while(iter != str.end())
{
it = t->branch.find(*iter);
if(it == t->branch.end())
{
TrieNode *node = new TrieNode(*iter);
t->branch[*iter] = node;
t = node;
}
else
{
t = t->branch[*iter];
}
++iter;
}
#endif
t->isWord = true;
}


void TrieTree::LevelOrder()const
{
queue<TrieNode *> que;
TrieNode *node = nullptr;
que.push(root);
while(!que.empty())
{
node = que.front();
que.pop();
cout<<node->value<<"  "<<node->isWord<<endl;;
#ifdef _TRIETREE_SET
for_each(node->branch.begin(),node->branch.end(),[&que](TrieNode *nod){que.push(nod);});
#else
for_each(node->branch.begin(),node->branch.end(),[&que](pair<const char,TrieNode*> &pair){que.push(pair.second);});
#endif
}
}


bool TrieTree::Contain(string &str)const
{
return Contain(str,0);
}


bool TrieTree::Contain(string &str,int n)const
{
bool flag = false;
TrieNode *t = root;
auto iter = str.begin();
auto it = t->branch.end();
#ifdef _TRIETREE_SET
while(iter != str.end())
{
it = find_if(t->branch.begin(),t->branch.end(),[&iter](TrieNode *node)->bool{return node->value == *iter;});
        if(it == t->branch.end())
{
break;
}
else
{
t = *it;
}
++iter;
}
#else
while(iter != str.end())
{
it = t->branch.find(*iter);
if(it == t->branch.end())
{
break;
}
else
{
t = t->branch[*iter];
}
++iter;
}
#endif
if(iter == str.end() && t->isWord)
flag = true;
return flag;
}


void TrieTree::PreOrder()const
{
cout<<"PreOrder:"<<endl;
PreOrder(root);
cout<<endl;
}




void TrieTree::PreOrder(TrieNode *t)const
{
if(t == nullptr)
return;
else
{
cout<<t->value<<" ";
//typedef void (TrieTree::*pFun)(TrieTree::TrieNode *)const;
//pFun fun = &TrieTree::PreOrder;
for(auto au : t->branch)
{
#ifdef _TRIETREE_SET
PreOrder(au);
#else
PreOrder(au.second);
#endif
}
}
}


void TrieTree::PostOrder()const
{
cout<<"PostOrder:"<<endl;
PostOrder(root);
cout<<endl;
}


void TrieTree::PostOrder(TrieNode *t)const
{
if(t == nullptr)
return;
else
{
for(auto au : t->branch)
{
#ifdef _TRIETREE_SET
PreOrder(au);
#else
PreOrder(au.second);
#endif
}
cout<<t->value<<" ";
}
}


bool TrieTree::PrefixCon(string &str)const
{
return PrefixCon(root,str);
}


bool TrieTree::PrefixCon(TrieNode *t,string &str)const
{
bool flag = false;
{
auto iter = str.begin();
auto it = t->branch.end();
while(iter != str.end())
{
#ifdef _TRIETREE_SET
it = find_if(t->branch.begin(),t->branch.end(),[&iter](TrieNode *node)->bool{return node->value == *iter;});
#else
it = t->branch.find(*iter);
#endif
if(it == t->branch.end())
{
flag = true;
break;
}
else
{
#ifdef  _TRIETREE_SET
t = *it;
#else
t = t->branch[*iter];
#endif
}
}
}
return flag;
}