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

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

数值算法/人工智能

开发平台：

MultiPlatform

node_list.h：源码内容
  1. /*******************************************************************************
  2. +
  3. +  LEDA-R  3.2.3
  4. +
  5. +  node_list.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_NODE_LIST_H
  14. #define LEDA_NODE_LIST_H
  16. //------------------------------------------------------------------------------
  17. // node_list
  18. //------------------------------------------------------------------------------
  20. #include <LEDA/graph.h>
  22. /*{Manpage {node_list} {} {Lists of Nodes} }*/
  25. class node_list : public c_obj_list {
  27. /*{Mdefinition
  28. An instance of the data type name is a doubly linked list of nodes. It
  29. is implemented more efficiently than the general list type $list<node>$ 
  30. (ref{Linear Lists}). However, it can only be used with the 
  31. restriction that every node is contained in at most one name.  }*/
  34. // private copy constructor (node_list's cannot be copied)
  36.   node_list(const node_list& ) {}
  38. public:
  40. /*{Mcreation L }*/
  42.   node_list() {};
  43. /*{Mcreate    introduces a variable var of type name and initializes
  44.                it with the empty list. }*/
  47. /*{Moperations 2 4.5 }*/
  49.   static void del_node(node v) { aux_link(v)->del_item(); }
  51.   void append(node v) { c_obj_list::append(aux_link(v)); }
  52. /*{Mop   appends $v$ to list var. }*/
  54.   void push(node v)   { c_obj_list::push(aux_link(v)); }
  55. /*{Mop   adds $v$ at the front of var. }*/
  57.   void insert(node v, node w) 
  58.                       { c_obj_list::insert(aux_link(v),aux_link(w)); }
  59. /*{Mop   inserts $v$ after $w$ into var.\
  60.           precond $w in L$. }*/
  63.   node pop()          { return node(aux_link(c_obj_list::pop())); }
  64. /*{Mop   deletes the first node from var and returns it.\
  65.           precond var is not empty. }*/
  67.   void del(node v)    { c_obj_list::del(aux_link(v)); }
  68. /*{Mop   deletes $v$ from var.\
  69.           precond $v in L$. }*/
  71.   bool member(node v)  const { return aux_link(v)->succ_link != nil; }
  72. /*{Mop    returns true if $v in L$ and false otherwise. }*/
  74.   bool operator()(node v) const { return member(v); }
  75. /*{Mfunop    returns true if $v in L$ and false otherwise. }*/
  78.   node head() const { return node(aux_link(c_obj_list::first())); }
  79.   node first()const { return node(aux_link(c_obj_list::first())); }
  80. /*{Mop    returns the first node in var (nil if var is empty).}*/
  82.   node tail() const { return node(aux_link(c_obj_list::last()));  }
  83.   node last() const { return node(aux_link(c_obj_list::last()));  }
  84. /*{Mop    returns the last node in var (nil if var is empty).}*/
  87.   node succ(node v) const
  88.   { return node(aux_link(c_obj_list::succ(aux_link(v)))); }
  89. /*{Mop    returns the successor of $v$ in var.\ 
  90.            precond $v in L$. }*/
  92.   node pred(node v) const
  93.   { return node(aux_link(c_obj_list::pred(aux_link(v)))); }
  94. /*{Mop    returns the predecessor of $v$ in var.\ 
  95.            precond $v in L$. }*/
  97.   node cyclic_succ(node v) const
  98.   { return node(aux_link(c_obj_list::cyclic_succ(aux_link(v)))); }
  99. /*{Mop    returns the cyclic successor of $v$ in var.\ 
  100.            precond $v in L$. }*/
  102.   node cyclic_pred(node v) const
  103.   { return node(aux_link(c_obj_list::cyclic_pred(aux_link(v)))); }
  104. /*{Mop    returns the cyclic predecessor of $v$ in var.\ 
  105.            precond $v in L$. }*/
  107. // iteration
  109.   node first_item() const { return first(); }
  110.   node last_item()  const { return last(); }
  112.   void loop_to_succ(GenPtr& x) const { x = succ(node(x)); }
  113.   void loop_to_pred(GenPtr& x) const { x = pred(node(x)); }
  115.   GenPtr forall_loop_test(GenPtr x, node& v) const { return v = node(x); }
  117. #if defined(__ELSE_SCOPE_BUG__)
  118.   GenPtr forall_loop_item;
  119.   GenPtr& Forall_Loop_Item() const { return (GenPtr&)forall_loop_item; }
  120. #endif
  122. };
  124. /*{Mtext
  125. bigskip
  126. {bf forall}($x,L$)
  127. ${$ ``the elements of $L$ are successively assigned to $x$'' $}$ }*/
  130. #endif