线性表、栈和队列

一、线性表（list）

1、定义：有序、有限的数据序列，其中的每个数据称为元素（element）。

　　注：在这里本文中所指的元素的数据类型相同。

2、基本概念：空（empty）、长度（length）、头（head）、尾（tail）、有序表（sorted list）、无序表（unsorted list）

3、基本操作：初始化、插入、删除、访问、修改

4、用抽象类（Abstract Base Class）表示：

template <typename E>
class List
{
private:
    void operator = (const List & ){}
    List(const List &){}
public:
    List(){}
    virtual ~List(){}
    virtual clear() =0;
    virtual void insert(const E & iteam) = 0；
    virtual append(const E& iteam)=0;
    virtual E remove()=0;
    virtual void moveToStart()=0;
    virtual viod moveToEnd()=0;
    virtual void prev()=0;//向左移动
    virtual void next()=0;
    virtual int length()const =0;
    virtual int currPos()const =0;
    virtual void moveToPos()=0;
    virtual const E& getValue()const =0;
};

5、线性表的实现

　　（1）数组表

template<typename E>
class AList : public List<E>
{
private:
    int maxSize;
    int listSize;
    int curr;
    E * listArray;
public:
    Alist(int size=defaultSize)
    {
        maxSize = size;
        listSize=curr=0;
        listArray=new [maxSize];
    }
    ~AList()
    {
        delete [] listArray;
    }
    void clear()
    {
        delete [] listArray;
        listSize=curr=0;
        listArray=new E[maxSize];
    }
    void insert(const E& IT)
    {
        Assert(listSize < maxSize,"List 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[i]=listArray[i+1];
        for(int i=curr;i<listSize;i++)
            listArray[i]=listArray[i++];
        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];
        }
};

（2）链表（linked list）

各个元素分布在内存中不同位置，其中每个元素称为节点（Node），每个节点包括自身的数据和指向下一个元素（节点）的指针（通常命名为next），因此要访问某一个节点只能先访问其上一个节点。也就是说访问其中任意一个节点都需要从头开始。

最后一个节点的指针next需要设置为Null。

template<type E>
class LList:public List
{
private:
    Link<E> * head;
    Link<E> * tail;
    Link<E> * curr;
    int cut;
    void init()
    {
        curr=tail=head=new Lind<E>;
        cnt=0;
    }
    void removeall()
    {
        while(head != NULL){
            curr=head;
            head =head->next;
            delete curr;
        }
    }
public:
    LList(int size=defaultSize){init();}
    ~List(){removeall();}
    void print() const;
    void clear(){removeall();init();}
    void insert(const E& it){
    curr->next=new Link<E>(i}t,NULL);
        cnt++;
    }
    void append(const E& it){
        tail=tail->next;
        cnt++;
    }
    E remove(){
        Assert(curr->next!=Null,"No element");
        E it = curr->net->element;
        Link<E> * ltemp=curr->next;
        if(tail==curr->next+ tail=curr;
            curr->next=curr->next->next;
            delete ltemp;
            cnt--;
            return it;
    }
    void moveToStart(){curr=head;}
    void moveToEnd(){curr=tail;}
    void prev(){
        if(curr==head)return;
        Link<E>* temp=head;
        while(temp->!=curr) temp=temp-next;
        curr=temp;
    }
    void next(){
        if (curr!=tail) curr=curr->next;
    }
    int length()const {return cnt;)
    int currPos()const {
        Link<E>* temp=head;
        int i;
        for(i=0;curr!=temp;i++)
            temp=temp->next;
        return i;
    }
    void moveToPos(int pos){
        Sssert((pos>=0)!&&(pos<=cnt),"Position out of range");
        curr=head;
        for(int i=0;i<pos;i++) curr=curr->next;
    }
    const E& getValue()const {
        Assert(curr->next!=NULL,"No value");
        return curr->next->element;
    }
};

在以上实现中为了方便查入节点，使指针指向所要指向元素的前一个节点。