lemon-0.x: comparison src/include/bin

equal deleted inserted replaced

-:6065f44a7450
+:4966e0fb69f3
 * the similar class by Alpar Juttner in IKTA...
 */
 /******
 *
-* BinHeap<KeyType, ValueType, KeyIntMap, [ValueCompare]>
+* BinHeap<ItemType, PrioType, ItemIntMap, [PrioCompare]>
 *
-* Ez az osztaly kulcs-ertek parok tarolasara alkalmas binaris kupacot
+* Ez az osztaly item-prioritas parok tarolasara alkalmas binaris kupacot
 * valosit meg.
-* A kupacban legfolul mindig az a par talalhato, amiben az _ertek_ a
+* A kupacban legfolul mindig az a par talalhato, amiben a prioritas a
 * legkisebb. (Gondolj a Dijkstra pont-tavolsag kupacara; igazabol ahhoz
 * lett keszitve...)
 *
-* Megjegyzes: egy kicsit gyanus nekem, hogy a kupacos temakorben nem
+* Megjegyzes: a kupacos temakorokben a prioritast kulcsnak szoktak nevezni,
-* azt hivjak kulcsnak, amit most en annak nevezek. :) En olyan
+* de mivel ez zavaro tud lenni a property-map-es kulcs-ertek szohasznalata
-* property_map -os ertelemben hasznalom.
+* miatt, megprobaltunk valami semleges elnevezeseket kitalalni.
 *
 * A hasznalatahoz szukseg van egy irhato/olvashato property_map-re, ami
-* a kulcsokhoz egy int-et tud tarolni (ezzel tudom megkeresni az illeto
+* az itemekhez egy int-et tud tarolni (ezzel tudom megkeresni az illeto
 * elemet a kupacban a csokkentes es hasonlo muveletekhez).
 * A map-re csak referenciat tarol, ugy hogy a kupac elete folyan a map-nek
 * is elnie kell. (???)
 *
 * Ketfele modon hasznalhato:
 * Lusta mod:
-* put(Key, Value) metodussal pakolunk a kupacba,
+* set(Item, Prio) metodussal pakolunk a kupacba,
 * aztan o majd eldonti, hogy ez az elem mar benne van-e es ha igen, akkor
 * csokkentettunk-e rajta, vagy noveltunk.
 * Ehhez nagyon fontos, hogy az atadott property map inicializalva legyen
 * minden szobajovo kulcs ertekre, -1 -es ertekkel!
 * Es ilyen esetben a kulcsokrol lekerdezheto az allapotuk a state metodussal:
 * (nem jart meg a kupacban PRE_HEAP=-1, epp a kupacban van IN_HEAP=0,
 *  mar kikerult a kupacbol POST_HEAP=-2).
 * Szoval ebben a modban a kupac nagyjabol hasznalhato property_map-kent, csak
-* meg meg tudja mondani a "legkisebb" erteku elemet. De csak nagyjabol,
+* meg meg tudja mondani a "legkisebb" prioritasu elemet. De csak nagyjabol,
 * hiszen a kupacbol kikerult elemeknek elvesz az ertekuk...
 *
 * Kozvetlen mod:
-* push(Key, Value) metodussal belerakunk a kupacba (ha az illeto kulcs mar
+* push(Item, Prio) metodussal belerakunk a kupacba (ha az illeto kulcs mar
 * benn volt, akkor gaz).
-* increase/decrease(Key k, Value new_value) metodusokkal lehet
+* increase/decrease(Item i, Prio new_prio) metodusokkal lehet
-* novelni/csokkenteni az illeto kulcshoz tartozo erteket. (Ha nem volt meg
+* novelni/csokkenteni az illeto elemhez tartozo prioritast. (Ha nem volt
-* benne a kupacban az illeto kulcs, vagy nem abba az iranyba valtoztattad
+* megbenne a kupacban az illeto elem, vagy nem abba az iranyba valtoztattad
 * az erteket, amerre mondtad -- gaz).
 *
 * Termeszetesen a fenti ket modot ertelemszeruen lehet keverni.
 * Ja es mindig nagyon gaz, ha belepiszkalsz a map-be, amit a kupac
 * hasznal. :-))
 #include <utility>
 #include <functional>
 namespace hugo {
-template <typename Key, typename Val, typename KeyIntMap,
+template <typename Item, typename Prio, typename ItemIntMap,
-	    typename Compare = std::less<Val> >
+	    typename Compare = std::less<Prio> >
 class BinHeap {
 public:
-typedef Key	             KeyType;
+typedef Item                             ItemType;
 // FIXME: stl-ben nem ezt hivjak value_type -nak, hanem a kovetkezot...
-typedef Val              ValueType;
+typedef Prio                             PrioType;
-typedef std::pair<KeyType,ValueType>     PairType;
+typedef std::pair<ItemType,PrioType>     PairType;
-typedef KeyIntMap        KeyIntMapType;
+typedef ItemIntMap                       ItemIntMapType;
-typedef Compare          ValueCompare;
+typedef Compare                          PrioCompare;
 /**
-* Each Key element have a state associated to it. It may be "in heap",
+* Each Item element have a state associated to it. It may be "in heap",
 * "pre heap" or "post heap". The later two are indifferent from the
 * heap's point of view, but may be useful to the user.
 *
-* The KeyIntMap _should_ be initialized in such way, that it maps
+* The ItemIntMap _should_ be initialized in such way, that it maps
 * PRE_HEAP (-1) to any element to be put in the heap...
 */
 enum state_enum {
 IN_HEAP = 0,
 PRE_HEAP = -1,
 private:
 std::vector<PairType> data;
 Compare comp;
 // FIXME: jo ez igy???
-KeyIntMap &kim;
+ItemIntMap &iim;
 public:
-BinHeap(KeyIntMap &_kim) : kim(_kim) {}
+BinHeap(ItemIntMap &_iim) : iim(_iim) {}
-BinHeap(KeyIntMap &_kim, const Compare &_comp) : comp(_comp), kim(_kim) {}
+BinHeap(ItemIntMap &_iim, const Compare &_comp) : comp(_comp), iim(_iim) {}
 int size() const { return data.size(); }
 bool empty() const { return data.empty(); }
 int bubble_up(int hole, PairType p);
 int bubble_down(int hole, PairType p, int length);
 void move(const PairType &p, int i) {
 data[i] = p;
-kim.put(p.first, i);
+iim.set(p.first, i);
 }
 void rmidx(int h) {
 int n = data.size()-1;
 if( h>=0 && h<=n ) {
-	kim.put(data[h].first, POST_HEAP);
+	iim.set(data[h].first, POST_HEAP);
 	if ( h<n ) {
 	  bubble_down(h, data[n], n);
 	}
 	data.pop_back();
 }
 void push(const PairType &p) {
 int n = data.size();
 data.resize(n+1);
 bubble_up(n, p);
 }
-void push(const Key &k, const Val &v) { push(PairType(k,v)); }
+void push(const Item &i, const Prio &p) { push(PairType(i,p)); }
-Key top() const {
+Item top() const {
 // FIXME: test size>0 ?
 return data[0].first;
 }
-Val topValue() const {
+Prio topPrio() const {
 // FIXME: test size>0 ?
 return data[0].second;
 }
 void pop() {
 rmidx(0);
 }
-void erase(const Key &k) {
+void erase(const Item &i) {
-rmidx(kim.get(k));
+rmidx(iim.get(i));
 }
-const Val get(const Key &k) const {
+const Prio get(const Item &i) const {
-int idx = kim.get(k);
+int idx = iim.get(i);
 return data[idx].second;
 }
-void put(const Key &k, const Val &v) {
+void set(const Item &i, const Prio &p) {
-int idx = kim.get(k);
+int idx = iim.get(i);
 if( idx < 0 ) {
-	push(k,v);
+	push(i,p);
 }
-else if( comp(v, data[idx].second) ) {
+else if( comp(p, data[idx].second) ) {
-	bubble_up(idx, PairType(k,v));
+	bubble_up(idx, PairType(i,p));
 }
 else {
-	bubble_down(idx, PairType(k,v), data.size());
+	bubble_down(idx, PairType(i,p), data.size());
 }
 }
-void decrease(const Key &k, const Val &v) {
+void decrease(const Item &i, const Prio &p) {
-int idx = kim.get(k);
+int idx = iim.get(i);
-bubble_up(idx, PairType(k,v));
+bubble_up(idx, PairType(i,p));
 }
-void increase(const Key &k, const Val &v) {
+void increase(const Item &i, const Prio &p) {
-int idx = kim.get(k);
+int idx = iim.get(i);
-bubble_down(idx, PairType(k,v), data.size());
+bubble_down(idx, PairType(i,p), data.size());
 }
-state_enum state(const Key &k) const {
+state_enum state(const Item &i) const {
-int s = kim.get(k);
+int s = iim.get(i);
 if( s>=0 )
 	s=0;
 return state_enum(s);
 }

changeset 200	f40bb16b0405
parent 114	bb07dd5b2d67
child 214	44f01e580f16