顺序表和链表

定义好虚基类List，预编译语句防止重复载入头文件，守卫宏

#ifndef __List_h
#define __List_h
template <typename E>
class List
{
private:
        void operator =(const List&){} //assignment
        List(const List&){}  //copy construct
public:
       List(){}  //default construct
       virtual ~List(){}  //destructor

       virtual void clear() = 0;   //make list empty
       //insert in current location
       virtual void insert(const E& item) = 0;
       //append at the end
       virtual void append(const E& item) = 0;
       //remove and return
       virtual E remove() = 0;
       //move to the head
       
       virtual void moveToStart() = 0;
       //move to the end
       virtual void moveToEnd() = 0;
       //move to prev
       virtual void prev() = 0;
       //move to nxt
       virtual void next() = 0;
       //get size
       virtual int length() const = 0;
       //get current position
       virtual int currPos() const = 0;
       //get current element
       virtual const E& getValue() const = 0;  
       
};
#endif

顺序表AList实现

#ifndef __AList_h
#define __AList_h
#include "List.h"
#include <assert.h>
#include <stdio.h>
template <typename E>
class AList :public List<E>
{
private:
        int maxSize;
        int listSize;
        int curr;
        E* listArray;
public:
       AList(int size = 100)
       {
            maxSize = size;
            listSize = curr = 0;
            listArray = new E[maxSize];
       }
       ~AList(){delete []listArray;}
       
       void clear()
       {
            delete []listArray;
            listSize = curr = 0;
            listArray = new E[maxSize];
        }

       void insert(const E& it)
       {
          assert(listSize<maxSize);  //ist capacity exceeded
          for(int i = listSize;i>curr;i--)
            listArray[i] = listArray[i-1];
        listArray[curr] = it;
        listSize++;
       }

       void append(const E& it)
       {
          assert(listSize<maxSize);  //list capacity exceeded
          listArray[listSize++] = it;
       }
       E remove()
       {
        assert((curr>=0)&&(curr<listSize));//no element
        E it = listArray[curr];
        for(int i=curr;i<listSize-1;i++)
          listArray[i] = listArray[i+1];
        listSize--;
        return it;
       }
       void moveToStart(){curr = 0;}
       void moveToEnd(){curr = listSize;}
       void prev(){if (curr!=0) curr--;}
       void next(){if(curr<listSize) curr++;}
       int length() const {return listSize;}
       int currPos() const{return curr;}
       void moveToPos(int pos)
       {
        assert((pos>=0)&&(pos<listSize));  //pos out of range
        curr = pos;
       }
       const E& getValue() const 
       {
        assert ((curr>=0)&&(curr<listSize)); //no current element
        return listArray[curr];
       }

};



#endif

遍历数组利用代码

for(mylist1.moveToStart();mylist1.currPos()<mylist1.length();mylist1.next())
               cout<<mylist1.getValue()<<" ";               

链表LList的实现

#ifndef __LList_h
#define __LList_h
#include "List.h"
#include <assert.h>
#include <stdio.h>
template <typename E>
class Link
{
public:
	E element;
	Link *next;
	Link(const E& elemval,Link* nextval=NULL)
	{ element = elemval;  next = nextval;}
	Link(Link* nextval=NULL)
	{next = nextval;}
};
template <typename E>
class LList : public List<E>
{
private:
	Link<E> *head,*tail,*curr;
	int cnt;
	void init(){
		curr = head = tail = new Link<E>;
		cnt = 0;
	}
	void removeall(){
		while(head!=NULL)
		{
			curr = head;
			head = head->next;
			delete curr;
		}
	}
public:
	LList(){init();}
	~LList(){removeall();}
	void print() const;
	void clear()
	{removeall(); init();}
	//if list is null tail = curr,else tail = curr->next
	//insert in curr->next,tail = curr->next
	void insert(const E& it)
	{
		curr->next = new Link<E>(it,curr->next);
		if(tail ==curr) tail = curr->next;
		cnt++;
	}
	void append(const E& it)
	{    //execute from right to left
		tail = tail->next = new Link<E>(it,NULL);
		cnt++;
	}
	//remove and return 
	E remove(){
		assert(curr->next!=NULL);
		E it = curr->next->element;
		Link<E>* ltemp = curr->next;  
		if(tail == curr->next)  //reset tail
			tail = curr;
		curr->next = curr->next->next;
		delete ltemp;
		cnt--;
		return it;
	}
	void moveToStart(){curr = head;}
	void moveToEnd(){curr = tail;}
	//iterator from head,to prev
	void prev(){
		if(curr == head) return ;
		Link<E>* temp = head;
		while(temp->next!=curr) temp = temp->next;
		curr = temp;
	}
	void next(){if(curr!=tail) curr = curr->next;}
	int length() const{return cnt;}
	//iterator from head and count
	int currPos() const{
		Link<E>* temp = head;
		int i;
		for(i = 0;curr!=temp;i++)
			temp = temp->next;
		return i;
	}
	void moveToPos(int pos){
		assert(pos>=0&&pos<=cnt);
		curr = head;
		for(int i = 0;i<pos;i++)
			curr = curr->next;
	}
	const E& getValue() const{
		assert(curr->next!=NULL);
		return curr->next->element;
		
	}
};
#endif

curr的使用类似头指针，访问数据也是curr->next->element,

所以curr,head都不存储数据，只是指向当前的链表位置，而tail是表尾的结点。