线性表栈和队列

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了线性表栈和队列相关的知识,希望对你有一定的参考价值。

一、线性表(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) = 0virtual 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;
    }
};

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

以上是关于线性表栈和队列的主要内容,如果未能解决你的问题,请参考以下文章

线性表栈和队列

线性结构(链表栈和队列中缀前缀后缀表达式转换)

数据结构和算法 数据结构基础线性表栈和队列数组和字符串

表栈和队列

栈和队列

数据结构复习--栈和队列--栈