20120918-LIST類定義《數據結構與算法分析》

LIST類結構

 1 template <typename Object>
 2 class List  3 {  4     private:  5         struct Node//全部都是公有的
 6  {  7  Object data;  8             Node *prev;  9             Node *next;  10 
 11             Node(const Object & d = Object(),Node *p = NUll，Node *n = Null):  12  data(d) , prev(p) , next(n)  13  {  14  }  15  };  16     public:  17         class const_iterator  18  {  19                 public:  20  const_iterator() : current(NULL){}  21                     const Object & operator* () const
 22  {  23                         return retrieve();  24  }  25                     const_iterator & operator++ ( ) const
 26  {  27                         current = current->next;  28                         return *this;  29  }  30                     const_iterator & operator++( int )  31  {  32                         const_iterator old = *this;  33                         ++(*this);  34                         return old;  35  }  36                     bool operator == (const const_iterator * rhs) const
 37  {  38                         return current == rhs.current;  39  }  40                     bool operator != (const const_iterator & rhs) const
 41  {  42                         return !(*this == rhs);  43  }  44 
 45             protected:  46                 Node *current;  47 
 48                 Object & retrieve() cosnt  49  {  50                     return current->data;  51  }  52                 const_iterator(Node *p) : current(p)  53  {  54  }  55                 friend class List<Object>;  56  };  57         class iterator : public const_iterator  58  {  59             public:  60  iterator()  61  {  62  }  63                 Object & operator* ()  64  {  65                     return retrieve();  66  }  67                 const Object & operator* () const
 68  {  69                     return const_iterator::operator*();  70  }  71                 iterator & operator++()  72  {  73                     iterator old = *this;  74                     ++(*this);  75                     return old;  76  }  77 
 78             protected:  79                 iterator(Node *p) : const_iterator(p)  80  {  81  }  82 
 83                 friend class List<object>;  84  };  85     public:  86  List()  87  {  88  init();  89  }  90         List(const List & rhs)  91  {  92  init();  93             *this = rhs;  94  }  95         ~List()  96  {  97  clear();  98  delete head;  99  delete tail; 100  } 101         const List & operator =(const List & rhs) 102  { 103             if(this == &rhs) 104                 return *this; 105  clear(); 106             for(const_iterator itr = rhs.begin();itr!=rhs.end();++itr) 107                 push_back(*itr); 108             return *this; 109  } 110         void init() 111  { 112             theSize = 0; 113             head = new Node; 114             tail = new Node; 115             head->next = tail; 116             tail->prev = head; 117  } 118 
119  iterator begin() 120  { 121             return iterator(head->next); 122  } 123         const_iterator begin() const
124  { 125             return const_iterator(head->next); 126  } 127  iterator end() 128  { 129             return iterator(tail); 130  } 131         const_iterator end() const
132  { 133             return const_iterator(tail); 134  } 135 
136         int size() const
137  { 138             return theSize; 139  } 140         bool empty() const
141  { 142             return size() == 0; 143  } 144         void clear() 145  { 146             while(!empty()) 147  pop_front(); 148  } 149         Object & front() 150  { 151             return *begin(); 152  } 153         const Object & front() const
154  { 155             return *begin(); 156  } 157         Object & back() 158  { 159             return *--end(); 160  } 161         const Object & back() const
162  { 163             return *--end(); 164  } 165         void push_front(const Object & x) 166  { 167  insert(begin(),x); 168  } 169         void push_back(const Object & x) 170  { 171  insert(end(),x); 172  } 173         void pop_front() 174  { 175  erase(begin()); 176  } 177  viod pop_back() 178  { 179  erase(end()); 180  } 181 
182         iterator insert(iterator itr,const Object & x) 183  { 184  } 185  iteratro erase(iterator itr ) 186  { 187  } 188  iterator erase(iterator start,iterator end) 189  { 190  } 191 
192 private: 193     int theSize; 194     Node *head; 195     Node *tail; 196 
197     void init() 198  { 199  } 200 }