Main Page | Namespace List | Class List | File List | Class Members | File Members

Trie.cpp

Go to the documentation of this file.
00001 /***************************************************************************
00002                           Trie.cpp  -  description
00003                              -------------------
00004     begin                : cs dec 26 2002
00005     copyright            : (C) 2002 by Ferenc Bodon
00006     email                : bodon@mit.bme.hu
00007  ***************************************************************************/
00008 
00009 
00010 #include "Trie.hpp"
00011 #include <cstdlib>
00012 #include <iostream>
00013 #include <algorithm>
00014 
00015 bool Edge_point_less(const Edge edge, const itemtype label)
00016 {
00017    return edge.label < label;
00018 };
00019 
00023 Trie::Trie( const unsigned long init_counter):
00024    counter(init_counter),
00025    maxpath(0)
00026 {
00027 }
00028 
00037 const Trie* Trie::is_included( const set<itemtype>& an_itemset, 
00038                                set<itemtype>::const_iterator item_it ) const
00039 {
00040    if( item_it == an_itemset.end() ) return this;
00041    else
00042    {
00043       vector<Edge>::const_iterator it_edgevector = 
00044          lower_bound(edgevector.begin(), edgevector.end(), 
00045                      *item_it, Edge_point_less);
00046       if( it_edgevector != edgevector.end() && 
00047           (*it_edgevector).label == *item_it )
00048          return (*it_edgevector).subtrie->is_included( an_itemset, ++item_it );
00049       else return NULL;
00050    }
00051 }
00052 
00061 void Trie::find_candidate( vector<itemtype>::const_iterator it_basket_upper_bound,
00062                            const itemtype distance_from_candidate,
00063                            vector<itemtype>::const_iterator it_basket, 
00064                            const unsigned long counter_incr)
00065 {
00066    if( distance_from_candidate )
00067    {
00068          vector<Edge>::iterator it_edge = edgevector.begin();
00069          while( it_edge != edgevector.end() 
00070                 && it_basket != it_basket_upper_bound )
00071          {
00072             if( (*it_edge).label < *it_basket) it_edge++;
00073             else if( (*it_edge).label > *it_basket) it_basket++;
00074             else
00075             {
00076                if( (*it_edge).subtrie->maxpath + 1 == distance_from_candidate )
00077                   (*it_edge).subtrie->find_candidate( it_basket_upper_bound + 1, 
00078                                                       distance_from_candidate - 1, 
00079                                                       it_basket + 1, counter_incr);
00080                it_edge++;
00081                it_basket++;
00082             }
00083          }
00084    }
00085    else counter += counter_incr;
00086 }
00087 
00094 void Trie::delete_infrequent( const double min_occurrence, 
00095                               const itemtype distance_from_candidate_parent )
00096 {
00097    vector<Edge>::iterator itEdge = edgevector.begin();
00098    if( distance_from_candidate_parent )
00099    {
00100       itemtype temp_maxpath = 0;
00101       for(  ;itEdge != edgevector.end(); itEdge++ )
00102       {
00103            if( (*itEdge).subtrie->maxpath == distance_from_candidate_parent )
00104               (*itEdge).subtrie->delete_infrequent( min_occurrence,
00105                                                     distance_from_candidate_parent - 1 );
00106            if( temp_maxpath < (*itEdge).subtrie->maxpath )
00107               temp_maxpath = (*itEdge).subtrie->maxpath;
00108       }
00109       maxpath = temp_maxpath + 1;
00110    }
00111    else
00112    {
00113       while ( itEdge != edgevector.end() )
00114       {
00115          if( (*itEdge).subtrie->counter < min_occurrence )
00116          {
00117             delete (*itEdge).subtrie;
00118             itEdge = edgevector.erase(itEdge);
00119          }
00120          else itEdge++;
00121       }
00122       if( edgevector.empty() )
00123          maxpath = 0;
00124    }
00125 }
00126 
00127 void Trie::show_content_preorder( ) const
00128 {
00129    cout<<"\ncounter: "<<counter<<" maxpath: "<<maxpath;
00130    for( vector<Edge>::const_iterator itEdge = edgevector.begin(); 
00131         itEdge != edgevector.end(); itEdge++ )
00132    {
00133       cout<<"\nitem"<<(*itEdge).label<<" leads to the Trie, where";
00134       (*itEdge).subtrie->show_content_preorder();
00135    }
00136    cout<<"\nNo more edges. Let's go back to the parent!";
00137 }
00138 
00139 Trie::~Trie()
00140 {
00141    for( vector<Edge>::iterator itEdge = edgevector.begin();
00142         itEdge != edgevector.end(); itEdge++ )
00143       delete (*itEdge).subtrie;
00144 }
00145 
00146 
00151 void Trie::add_empty_state( const itemtype item, const unsigned long counter )
00152 {
00153    Edge temp_edge;
00154    temp_edge.label = item;
00155    temp_edge.subtrie = new Trie( counter );
00156    edgevector.push_back(temp_edge);
00157 }

Generated on Mon Aug 16 19:59:29 2004 for APRIORI algorithm by doxygen 1.3.5