数据结构--队列--顺序表实现

队列 先进先出

c++中STL

#include <iostream>
#include <queue>
using namespace std;

int main(){
    queue<int> q;
    q.push(1);
    q.push(2);
    q.push(3);
    q.push(4);
    while(!q.empty()){
        cout << q.front() << endl;
        q.pop();
    }
    return 0;
}

1
2
3
4

全部代码

#include <iostream>
#include <stdexcept>
using namespace std;
template<typename T>
class Queue{
private:
    T *data;
    int front;//指向队首
    int rear;//指向队尾后面的一个元素
    int capacity;
    void resize();//动态数组需要扩容
public:
    Queue() : data(new T[capacity]),front(0),rear(0),capacity(10) {}
   // Queue() : data(new T[10]),front(0),rear(0),capacity(10) {}
    //初始化 ：舒适化列表
    ~Queue();//析构函数
    void enqueue(T element);//入队函数
    T dequeue();//出队函数
    T getFront() const;//获取队头元素
    int getSize() const;//获取队列长度
};
template<typename T>
void Queue<T>::resize(){
    T *newData = new T[capacity * 2];
    for (int i = 0; i < rear; i++) {
        newData[i] = data[i];
    }
    delete[] data;
    data = newData;
    capacity *= 2;
};
template<typename T>
Queue<T>::~Queue(){
    delete[] data;
};//析构函数
template<typename T>
void Queue<T>::enqueue(T element){
    if(rear == capacity){
        resize();
    }
    data[rear++] = element;
};//入队函数

template<typename T>
T Queue<T>::dequeue(){
    if(front == rear){
        throw std::underflow_error("Queue is empty");
    }
    return data[front++];
};//出队函数
template<typename T>
T Queue<T>::getFront() const{
 	if(front == rear){
        throw std::underflow_error("Queue is empty");
    }
    return data[front];
};//获取队头元素
template<typename T>
int Queue<T>::getSize() const{
    return rear - front;
};//获取队列长度

int main() {
    Queue<int> q;
    q.enqueue(3);
    q.enqueue(4);
    cout << q.getFront() << endl;
    q.enqueue(5);
    cout << q.getFront() << endl;
    q.dequeue();
    cout << q.getFront() << endl;
    cout << q.getSize() << endl;
    return 0;
}

输出

3
3
4
2

动态数组需要扩容

template<typename T>
void Queue<T>::resize(){
    T *newData = new T[capacity * 2];
    for (int i = 0; i < rear; i++) {
        newData[i] = data[i];
    }
    delete[] data;
    data = newData;
    capacity *= 2;
};

析构函数

template<typename T>
Queue<T>::~Queue(){
    delete[] data;
};//析构函数

入队函数

template<typename T>
void Queue<T>::enqueue(T element){
    if(rear == capacity){
        resize();
    }
    data[rear++] = element;
};//入队函数

出队函数

template<typename T>
T Queue<T>::dequeue(){
    if(front == rear){
        throw std::underflow_error("Queue is empty");
    }
    return data[front++];
};//出队函数

获取队头元素

template<typename T>
T Queue<T>::getFront() const{
	 if(front == rear){
        throw std::underflow_error("Queue is empty");
    }
    return data[front];
};//获取队头元素

获取队列长度

template<typename T>
int Queue<T>::getSize() const{
    return rear - front;
};//获取队列长度