Changeset 172:c645f4a2a6ae in lemon0.x for src
 Timestamp:
 03/11/04 20:24:28 (16 years ago)
 Branch:
 default
 Phase:
 public
 Convert:
 svn:c9d7d8f590d60310b91f818b3a526b0e/lemon/trunk@245
 Location:
 src
 Files:

 2 edited
Legend:
 Unmodified
 Added
 Removed

src/include/bin_heap.hh
r114 r172 7 7 /****** 8 8 * 9 * BinHeap< KeyType, ValueType, KeyIntMap, [ValueCompare]>10 * 11 * Ez az osztaly kulcsertekparok tarolasara alkalmas binaris kupacot9 * BinHeap<ItemType, PrioType, ItemIntMap, [PrioCompare]> 10 * 11 * Ez az osztaly itemprioritas parok tarolasara alkalmas binaris kupacot 12 12 * valosit meg. 13 * A kupacban legfolul mindig az a par talalhato, amiben a z _ertek_a13 * A kupacban legfolul mindig az a par talalhato, amiben a prioritas a 14 14 * legkisebb. (Gondolj a Dijkstra ponttavolsag kupacara; igazabol ahhoz 15 15 * lett keszitve...) 16 16 * 17 * Megjegyzes: egy kicsit gyanus nekem, hogy a kupacos temakorben nem18 * azt hivjak kulcsnak, amit most en annak nevezek. :) En olyan19 * property_map os ertelemben hasznalom.17 * Megjegyzes: a kupacos temakorokben a prioritast kulcsnak szoktak nevezni, 18 * de mivel ez zavaro tud lenni a propertymapes kulcsertek szohasznalata 19 * miatt, megprobaltunk valami semleges elnevezeseket kitalalni. 20 20 * 21 21 * A hasznalatahoz szukseg van egy irhato/olvashato property_mapre, ami 22 * a kulcsokhoz egy intet tud tarolni (ezzel tudom megkeresni az illeto22 * az itemekhez egy intet tud tarolni (ezzel tudom megkeresni az illeto 23 23 * elemet a kupacban a csokkentes es hasonlo muveletekhez). 24 24 * A mapre csak referenciat tarol, ugy hogy a kupac elete folyan a mapnek … … 27 27 * Ketfele modon hasznalhato: 28 28 * Lusta mod: 29 * put(Key, Value) metodussal pakolunk a kupacba,29 * set(Item, Prio) metodussal pakolunk a kupacba, 30 30 * aztan o majd eldonti, hogy ez az elem mar benne vane es ha igen, akkor 31 31 * csokkentettunke rajta, vagy noveltunk. … … 36 36 * mar kikerult a kupacbol POST_HEAP=2). 37 37 * Szoval ebben a modban a kupac nagyjabol hasznalhato property_mapkent, csak 38 * meg meg tudja mondani a "legkisebb" erteku elemet. De csak nagyjabol,38 * meg meg tudja mondani a "legkisebb" prioritasu elemet. De csak nagyjabol, 39 39 * hiszen a kupacbol kikerult elemeknek elvesz az ertekuk... 40 40 * 41 41 * Kozvetlen mod: 42 * push( Key, Value) metodussal belerakunk a kupacba (ha az illeto kulcs mar42 * push(Item, Prio) metodussal belerakunk a kupacba (ha az illeto kulcs mar 43 43 * benn volt, akkor gaz). 44 * increase/decrease( Key k, Value new_value) metodusokkal lehet45 * novelni/csokkenteni az illeto kulcshoz tartozo erteket. (Ha nem volt meg46 * benne a kupacban az illeto kulcs, vagy nem abba az iranyba valtoztattad44 * increase/decrease(Item i, Prio new_prio) metodusokkal lehet 45 * novelni/csokkenteni az illeto elemhez tartozo prioritast. (Ha nem volt 46 * megbenne a kupacban az illeto elem, vagy nem abba az iranyba valtoztattad 47 47 * az erteket, amerre mondtad  gaz). 48 48 * … … 66 66 namespace hugo { 67 67 68 template <typename Key, typename Val, typename KeyIntMap,69 typename Compare = std::less< Val> >68 template <typename Item, typename Prio, typename ItemIntMap, 69 typename Compare = std::less<Prio> > 70 70 class BinHeap { 71 71 72 72 public: 73 typedef Key KeyType;73 typedef Item ItemType; 74 74 // FIXME: stlben nem ezt hivjak value_type nak, hanem a kovetkezot... 75 typedef Val ValueType;76 typedef std::pair< KeyType,ValueType> PairType;77 typedef KeyIntMap KeyIntMapType;78 typedef Compare ValueCompare;75 typedef Prio PrioType; 76 typedef std::pair<ItemType,PrioType> PairType; 77 typedef ItemIntMap ItemIntMapType; 78 typedef Compare PrioCompare; 79 79 80 80 /** 81 * Each Keyelement have a state associated to it. It may be "in heap",81 * Each Item element have a state associated to it. It may be "in heap", 82 82 * "pre heap" or "post heap". The later two are indifferent from the 83 83 * heap's point of view, but may be useful to the user. 84 84 * 85 * The KeyIntMap _should_ be initialized in such way, that it maps85 * The ItemIntMap _should_ be initialized in such way, that it maps 86 86 * PRE_HEAP (1) to any element to be put in the heap... 87 87 */ … … 96 96 Compare comp; 97 97 // FIXME: jo ez igy??? 98 KeyIntMap &kim;98 ItemIntMap &iim; 99 99 100 100 public: 101 BinHeap( KeyIntMap &_kim) : kim(_kim) {}102 BinHeap( KeyIntMap &_kim, const Compare &_comp) : comp(_comp), kim(_kim) {}101 BinHeap(ItemIntMap &_iim) : iim(_iim) {} 102 BinHeap(ItemIntMap &_iim, const Compare &_comp) : comp(_comp), iim(_iim) {} 103 103 104 104 … … 118 118 void move(const PairType &p, int i) { 119 119 data[i] = p; 120 kim.put(p.first, i);120 iim.set(p.first, i); 121 121 } 122 122 … … 124 124 int n = data.size()1; 125 125 if( h>=0 && h<=n ) { 126 kim.put(data[h].first, POST_HEAP);126 iim.set(data[h].first, POST_HEAP); 127 127 if ( h<n ) { 128 128 bubble_down(h, data[n], n); … … 138 138 bubble_up(n, p); 139 139 } 140 void push(const Key &k, const Val &v) { push(PairType(k,v)); }141 142 Keytop() const {140 void push(const Item &i, const Prio &p) { push(PairType(i,p)); } 141 142 Item top() const { 143 143 // FIXME: test size>0 ? 144 144 return data[0].first; 145 145 } 146 Val topValue() const {146 Prio topPrio() const { 147 147 // FIXME: test size>0 ? 148 148 return data[0].second; … … 153 153 } 154 154 155 void erase(const Key &k) {156 rmidx( kim.get(k));157 } 158 159 const Val get(const Key &k) const {160 int idx = kim.get(k);155 void erase(const Item &i) { 156 rmidx(iim.get(i)); 157 } 158 159 const Prio get(const Item &i) const { 160 int idx = iim.get(i); 161 161 return data[idx].second; 162 162 } 163 void put(const Key &k, const Val &v) {164 int idx = kim.get(k);163 void set(const Item &i, const Prio &p) { 164 int idx = iim.get(i); 165 165 if( idx < 0 ) { 166 push( k,v);167 } 168 else if( comp( v, data[idx].second) ) {169 bubble_up(idx, PairType( k,v));166 push(i,p); 167 } 168 else if( comp(p, data[idx].second) ) { 169 bubble_up(idx, PairType(i,p)); 170 170 } 171 171 else { 172 bubble_down(idx, PairType( k,v), data.size());173 } 174 } 175 176 void decrease(const Key &k, const Val &v) {177 int idx = kim.get(k);178 bubble_up(idx, PairType( k,v));179 } 180 void increase(const Key &k, const Val &v) {181 int idx = kim.get(k);182 bubble_down(idx, PairType( k,v), data.size());183 } 184 185 state_enum state(const Key &k) const {186 int s = kim.get(k);172 bubble_down(idx, PairType(i,p), data.size()); 173 } 174 } 175 176 void decrease(const Item &i, const Prio &p) { 177 int idx = iim.get(i); 178 bubble_up(idx, PairType(i,p)); 179 } 180 void increase(const Item &i, const Prio &p) { 181 int idx = iim.get(i); 182 bubble_down(idx, PairType(i,p), data.size()); 183 } 184 185 state_enum state(const Item &i) const { 186 int s = iim.get(i); 187 187 if( s>=0 ) 188 188 s=0; 
src/work/bin_heap_demo.cc
r105 r172 26 26 return operator[](s); 27 27 } 28 void put(const string &s, int i) {28 void set(const string &s, int i) { 29 29 operator[](s) = i; 30 30 } … … 46 46 heap.push("alma", 15); 47 47 48 cout << "heap. put(\"korte\", 3.4);\n";49 heap. put("korte", 3.4);48 cout << "heap.set(\"korte\", 3.4);\n"; 49 heap.set("korte", 3.4); 50 50 51 51 cout << "heap.get(\"alma\") = " … … 55 55 cout << "heap.top() = " 56 56 << heap.top() << endl; 57 cout << "heap.top Value() = "58 << heap.top Value() << endl;57 cout << "heap.topPrio() = " 58 << heap.topPrio() << endl; 59 59 60 60 cout << "heap.decrease(\"alma\", 1.2);\n"; 61 heap. put("alma", 1.2);61 heap.set("alma", 1.2); 62 62 63 63 cout << "heap.top() = " 64 64 << heap.top() << endl; 65 cout << "heap.top Value() = "66 << heap.top Value() << endl;65 cout << "heap.topPrio() = " 66 << heap.topPrio() << endl; 67 67 68 cout << "heap. put(\"alma\", 22);\n";69 heap. put("alma", 22);68 cout << "heap.set(\"alma\", 22);\n"; 69 heap.set("alma", 22); 70 70 71 71 cout << "heap.top() = " 72 72 << heap.top() << endl; 73 cout << "heap.top Value() = "74 << heap.top Value() << endl;73 cout << "heap.topPrio() = " 74 << heap.topPrio() << endl; 75 75 76 76 cout << "heap.size() = " … … 81 81 cout << "heap.top() = " 82 82 << heap.top() << endl; 83 cout << "heap.top Value() = "84 << heap.top Value() << endl;83 cout << "heap.topPrio() = " 84 << heap.topPrio() << endl; 85 85 86 86 cout << "heap.state(\"szilva\") = " 87 87 << heap.state("szilva") << endl; 88 cout << "heap. put(\"szilva\", 0.5);\n";89 heap. put("szilva", 0.5);88 cout << "heap.set(\"szilva\", 0.5);\n"; 89 heap.set("szilva", 0.5); 90 90 cout << "heap.state(\"szilva\") = " 91 91 << heap.state("szilva") << endl;
Note: See TracChangeset
for help on using the changeset viewer.