队

来源：互联网发布：人工智能基础编辑：程序博客网时间：2024/05/17 06:34

队是先进先出的数据结构。需要一头一尾两个指针，front和rear。

template<class T>class queue {   public:      virtual ~queue() {}      virtual bool empty() const = 0;                  // return true iff queue is empty      virtual int size() const = 0;                  // return number of elements in queue      virtual T& front() = 0;                  // return reference to the front element      virtual T& back() = 0;                  // return reference to the back element      virtual void pop() = 0;                  // remove the front element      virtual void push(const T& theElement) = 0;                  // add theElement at the back of the queue};

ArrayQueue
这里采用循环数组存储。location(i)=(location(1)+i-1)%maxsize
循环数组初始化：front=rear=0
循环数组满：(rear+1)%maxsize=front
循环数组最大容量：maxsize-1

template<class T>class ArrayStack:public queue {    public:        queue(int capacity=10){            arrayLength=capacity;            front=rear=0;            element=new T[arrayLength];        }        int size(){            return (rear-front+arrayLength)%arrayLength;        }        T& front(){            return element[（front+1）%arrayLength];        }        T& back(){            return element[rear];        }        void pop(){            element[（front+1）%arrayLength].~T();            front=（front+1）%arrayLength;        }        void push(const T& theElement){            //这里在发现数组满的时候并没有采用change1Dlength函数，因为这个数组是循环            //不能单纯的将数组元素从头到尾复制到新的数组，元素的起始位置可能在中间            if(size()==arrayLength-1)            {                int start=(front+1)%arrayLength;                T* newqueue=new T[arrayLength*2];                if(start<2) //此时数组元素在循环数组中都是从头到尾                {                    copy(queue+start,queue+start+arraylenth-1,newqueue);                }                else                 {                    //copy(a,b,n)函数的复制的范围是[a,b)                    copy(queue+start,queue+arrayLength,newqueue);                    copy(queue,queue+rear+1,newqueue+arrayLength-start);                }                front=arrayLength*2-1;                rear=arrayLength-2;//元素个数是arrayLength-1                arrayLength*=2;                queue=newqueue;            }            rear=(rear+1)%arrayLength;            element[rear]=theElement;        }    private:        //这里也不用定义数组元素大小的变量，可以通过front和rear来计算        int front;        int rear;        T* element;        int arrayLength;}

LinkedQueue
这里写图片描述
可以使用链表来实现一个队列，此时需要两个变量front和rear来分别跟踪队列的两端，此时可能有两种情形：从front开始，链接到rear；或者从rear开始，链接到front。不同的链接方式元素删除和插入的难易程度不同，对于添加元素，两种方式的难易程度一样，但是对于删除元素，采用方式a更加方便。因此在用链表来实现队列的时候，我们采用方式a。

class LinkedQueue:public queue{    public:    linkedQueue(){        front=NULL;        rear=NULL;        size=0;    }    ~linkedQueue(){        while(front)        {             ListNode* node=front->next;            delete front;            front=node;        }    }    void pop(){        if(empty()) throw ...        ListNode* node=front->next;        delete front;        front=node;        size--;    }    void push(const T& theElement)    {        ListNode* node=new ListNode(theElement);        if(empty()) front=node;        else rear->next=node;        rear=node;        size++;    }    private:        listNode* front;        ListNode* rear;        int size;}

0 0