开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 查看源码
slist.h
资源名称：leda.tar.gz　[点击查看]
上传用户：gzelex
上传日期：2007-01-07
资源大小：707k
文件大小：4k
源码类别：

数值算法/人工智能

开发平台：

MultiPlatform

slist.h：源码内容
  1. /*******************************************************************************
  2. +
  3. +  LEDA-R  3.2.3
  4. +
  5. +  slist.h
  6. +
  7. +  Copyright (c) 1995  by  Max-Planck-Institut fuer Informatik
  8. +  Im Stadtwald, 66123 Saarbruecken, Germany     
  9. +  All rights reserved.
  10. + 
  11. *******************************************************************************/
  13. #ifndef LEDA_IMPL_SLIST_H
  14. #define LEDA_IMPL_SLIST_H
  16. //------------------------------------------------------------------------------
  17. // simply linked lists
  18. //------------------------------------------------------------------------------
  21. #include <LEDA/basic.h>
  24. class SLIST; 
  25. class slink;
  27. typedef slink* slist_item;
  29. //------------------------------------------------------------------------------
  30. // class slink 
  31. //------------------------------------------------------------------------------
  33. class slink {
  35.   friend class SLIST;
  37.   slink* succ;
  38.   GenPtr e;
  40.   slink(GenPtr a, slink* suc) { e = a; succ = suc; }
  42.   LEDA_MEMORY(slink)
  44. };
  47. //------------------------------------------------------------------------------
  48. // SLIST: base class for all simply linked Lists
  49. //------------------------------------------------------------------------------
  51. class SLIST {
  53.    slink* h;                     //head
  54.    slink* t;                     //tail
  55.    slink* iterator;              //iterator;
  56.    int    count;                 //length of List
  58. virtual void clear_el(GenPtr&) const {}
  59. virtual void copy_el(GenPtr&)  const {}
  60. virtual int  int_type() const { return 0; }
  62. public:
  64.    int space()  const { return sizeof(SLIST) + count * sizeof(slink); }
  65.    int length() const { return count; }
  66.    bool empty()  const { return (count==0);}
  68.    slink* insert(GenPtr, slink*);
  71.    slink* push(GenPtr a)   
  72.    { count++;
  73.      h = new slink(a,h); 
  74.      if (t==0) t = h;
  75.      return h;
  76.    }
  78.    slink* append(GenPtr a)
  79.    { count++;
  80.      if (t) t = t->succ = new slink(a,0); 
  81.      else   t = h = new slink(a,0); 
  82.      return t;
  83.    } 
  85.    slink* first()               const { return h; }
  86.    slink* first_item()          const { return h; }
  87.    slink* last()                const { return t; }
  88.    slink* last_item()           const { return t; }
  89.    slink* next_item(slink* p)   const { return p->succ; }
  90.    slink* succ(slink* l)        const { return l->succ; }
  91.    slink* cyclic_succ(slink*)   const;
  94. // iteration
  96.    GenPtr loop_to_succ(GenPtr& x) const { return x = slist_item(x)->succ; }
  98. #if defined(__ELSE_SCOPE_BUG__)
  99.    GenPtr forall_loop_item;
  100.    GenPtr& Forall_Loop_Item() const { return (GenPtr&)forall_loop_item; }
  101. #endif
  103. // old iteration stuff
  105.    void   set_iterator(slink* p)   const { *(slink**)&iterator = p; }
  106.    slink* get_iterator()  const { return iterator; }
  107.    void   init_iterator() const { set_iterator(0); }
  109.    slink* move_iterator() const  
  110.    { set_iterator( iterator ? iterator->succ : h);
  111.      return iterator;
  112.    } 
  114.    void conc(SLIST&);
  116.    GenPtr head()   const { return h ? h->e : 0;}
  117.    GenPtr tail()   const { return t ? t->e : 0;}
  118.    GenPtr pop();
  120.    void del_succ(slink* p)    
  121.    { slink* q = p->succ;
  122.      if (q == t) t = p;
  123.      p->succ = q->succ; 
  124.      delete q;
  125.      count--;
  126.    }
  128.    bool current_element(GenPtr& x)  const
  129.    { if (!iterator) return false;
  130.      else { x = iterator->e;
  131.             return true; }
  132.     }
  134.    bool next_element(GenPtr& x) const 
  135.   { move_iterator(); 
  136.     return current_element(x); 
  137.    }
  139.    GenPtr  contents(slink* l)  const  { return l->e; }
  140.    GenPtr& entry(slink* l)            { return l->e; }
  141.    GenPtr& operator[](slink* l)       { return l->e; }
  142.    GenPtr  operator[](slink* l) const { return l->e; }
  144.    void clear();
  146.    SLIST();    
  147.    SLIST(GenPtr a);
  148.    SLIST& operator=(const SLIST&); 
  149.    SLIST(const SLIST&);
  150.    virtual ~SLIST()     { clear(); }
  151. };
  154. #if !defined(__TEMPLATE_FUNCTIONS__)
  155. // dummy I/O and cmp functions
  157. inline void Print(const SLIST&,ostream&) { }
  158. inline void Read(SLIST&, istream&) { }
  159. inline int  compare(const SLIST&,const SLIST&) { return 0; }
  160. #endif
  162. #endif