顺序队列(Sequential Queue)

顺序队列(Sequential Queue)

1. 顺序队列的概念

1.1 顺序队列的定义

  • 顺序队列是基于数组的存储表示实现的队列。

1.2 顺序队列中各元素的逻辑及存储关系

  • 顺序队列可以采用顺序表作为其存储表示，因此，可以在顺序队列的声明中用顺序表定义它的存储空间。
  • 顺序队列可以使用一维数组作为队列的存储空间，存放队列元素的数组的头指针为*elements，该数组的最大允许存放元素个数为maxSize，当前队列的队头位置由数组下标指针front指示，队尾位置由数组下标指针rear指示，如果队列不为空时elements[0]是队列中第一个元素。

2. 顺序队列的实现

2.1 队列基类的定义

  • 文件：Queue.h

    
#ifndef QUEUE_H_

#define QUEUE_H_

template <class T>
class Queue
{
public:
    Queue(){}                               //构造函数
    virtual ~Queue(){}                      //析构函数
public:
    virtual void EnQueue(const T& x) = 0;       //新元素x入队
    virtual bool DeQueue(T& x) = 0;             //队头元素出队，并将该元素的值保存至x
    virtual bool getFront(T& x) const = 0;      //读取队头元素，并将该元素的值保存至x
    virtual bool getRear(T& x) const = 0;       //读取队尾元素，并将该元素的值保存至x
    virtual bool IsEmpty() const = 0;           //判断队列是否为空
    virtual bool IsFull() const = 0;            //判断队列是否为满
    virtual int getSize() const = 0;            //计算队列中元素个数
    virtual void MakeEmpty() = 0;               //清空队列的内容
};

#endif /* QUEUE_H_ */

2.2 顺序队列的类定义及其操作的实现

  • 文件：SeqQueue.h

    
#ifndef SEQ_QUEUE_H_

#define SEQ_QUEUE_H_

#include "Queue.h"

#include <iostream>

#include <string>

#include <strstream>

using namespace std;

const int defaultSize = 50;
const int queueIncreament = 20;

template <class T>
class SeqQueue : public Queue<T>
{
public:
    SeqQueue(int sz = defaultSize);     //构造函数
    virtual ~SeqQueue();                //析构函数
public:
    virtual void EnQueue(const T& x);       //新元素x入队
    virtual bool DeQueue(T& x);             //队头元素出队，并将该元素的值保存至x
    virtual bool getFront(T& x) const;      //读取队头元素，并将该元素的值保存至x
    virtual bool getRear(T& x) const;       //读取队尾元素，并将该元素的值保存至x
    virtual bool IsEmpty() const;           //判断队列是否为空
    virtual bool IsFull() const;            //判断队列是否为满
    virtual int getSize() const;            //计算队列中元素个数
    virtual void MakeEmpty();               //清空队列的内容
public:
    template <class T>
    friend ostream& operator<<(ostream& os, const SeqQueue<T>& s);  //输出队列元素的重载操作<<
private:
    void overflowProcess();             //队列的溢出处理
private:
    T *elements;    //存放队列元素的队列数组
    int front;      //队头指针
    int rear;       //队尾指针
    int maxSize;    //队列最大可容纳元素个数
};

//构造函数
template <class T>
SeqQueue<T>::SeqQueue(int sz)
{
    cout << "$ 执行构造函数" << endl;
    if (sz >= 0)
    {
        maxSize = sz;
        front = rear = -1;
        elements = new T[maxSize];
    }
}                       

//析构函数
template <class T>
SeqQueue<T>::~SeqQueue()
{
    cout << "$ 执行析构函数" << endl;
    delete[] elements;
    elements = NULL;
}   

//新元素x入队
template <class T>
void SeqQueue<T>::EnQueue(const T& x)
{
    if (true == IsFull())
    {
        overflowProcess();
    }
    (0 == getSize()) ? ++front : front;
    elements[++rear] = x;
}

//队头元素出队，并将该元素的值保存至x
template <class T>
bool SeqQueue<T>::DeQueue(T& x)
{
    if (true == IsEmpty())
    {
        return false;
    }
    x = elements[front];
    for (int i = front; i < rear; i++)
    {
        elements[i]= elements[i+1];
    }
    (1 == getSize()) ? front-- : front;
    rear--;
    return true;
}

//读取队头元素，并将该元素的值保存至x
template <class T>
bool SeqQueue<T>::getFront(T& x) const
{
    if (true == IsEmpty())
    {
        return false;
    }
    x = elements[front];
    return true;
}

//读取队尾元素，并将该元素的值保存至x
template <class T>
bool SeqQueue<T>::getRear(T& x) const
{
    if (true == IsEmpty())
    {
        return false;
    }
    x = elements[rear];
    return true;
}

//判断队列是否为空
template <class T>
bool SeqQueue<T>::IsEmpty() const
{
    return ((-1 == front) && (-1 == rear)) ? true : false;
}

//判断队列是否为满
template <class T>
bool SeqQueue<T>::IsFull() const
{
    return (maxSize - 1 == rear) ? true : false;
}

//计算队列中元素个数
template <class T>
int SeqQueue<T>::getSize() const
{
    return rear + 1;
}

//清空队列的内容
template <class T>
void SeqQueue<T>::MakeEmpty()
{
    delete[] elements;
    front = rear = -1;
    elements = new T[maxSize];
}

//输出队列元素的重载操作<<
template <class T>
ostream& operator<<(ostream& os, const SeqQueue<T>& s)
{
    for (int i = s.front; i <= s.rear && i != -1; i++)
    {
        os << "[" << i << "]" << " : " << s.elements[i] << endl;
    }
    return os;
}

//队列的溢出处理
template <class T>
void SeqQueue<T>::overflowProcess()
{
    cout << "$ 执行队列的溢出处理函数" << endl;
    int newSize = maxSize + queueIncreament;
    T *newelements = new T[newSize];
    for (int i = front; i <= rear && i != -1; i++)
    {
        newelements[i] = elements[i];
    }
    delete[] elements;
    elements = newelements;
    maxSize = newSize;
}

#endif /* SEQ_QUEUE_H_ */

2.3 主函数(main函数)的实现

  • 文件：main.cpp

    
#include "SeqQueue.h"

#define EXIT 0              //退出

#define ENQUEUE 1           //新元素x入队

#define DEQUEUE  2          //队头元素出队，并将该元素的值保存至x

#define GETFRONT 3          //读取队头元素，并将该元素的值保存至x

#define GETREAR 4           //读取队尾元素，并将该元素的值保存至x

#define ISEMPTY  5          //判断队列是否为空

#define ISFULL 6            //判断队列是否为满

#define GETSIZE 7           //计算队列中元素个数

#define MAKEEMPTY 8         //清空队列的内容

#define OPERATOR_OSTREAM 9  //输出队列元素的重载操作<<

void print_description()
{
    cout << "------------------------------>顺序队列<------------------------------" << endl;
    cout << "功能选项说明：" << endl;
    cout << "#0： 退出" << endl;
    cout << "#1： 新元素x入队" << endl;
    cout << "#2： 队头元素出队，并将该元素的值保存至x" << endl;
    cout << "#3： 读取队头元素，并将该元素的值保存至x" << endl;
    cout << "#4： 读取队尾元素，并将该元素的值保存至x" << endl;
    cout << "#5： 判断队列是否为空" << endl;
    cout << "#6： 判断队列是否为满" << endl;
    cout << "#7： 计算队列中元素个数" << endl;
    cout << "#8： 清空队列的内容" << endl;
    cout << "#9： 输出队列元素的重载操作<<" << endl;
    cout << "--------------------------------------------------------------------" << endl;
}

//判断输入的字符串每个字符是否都是数值0~9
bool IsNumber(const string& s_num)
{
    for (size_t i = 0; i < s_num.size(); i++)
    {
        if ((s_num[i] < ‘0‘) || (s_num[i] > ‘9‘))
        {
            return false;
        }
    }
    return true;
}

//类型转换——将string型转为模板类型T
template <class T>
T StrToTtype(const string& s_num)
{
    T n_num;
    strstream ss_num;
    ss_num << s_num;
    ss_num >> n_num;
    return n_num;
}

//输入数据值
template <class T>
T get_data()
{
    cout << "> 请输入数据值，data = ";
    string s_data;
    cin >> s_data;
    return StrToTtype<T>(s_data);
}

//输入数组的最大长度
template <class T>
int get_maxsize()
{
    cout << "> 请输入数组的最大长度，maxsize = ";
    string s_maxsize;
    cin >> s_maxsize;
    while (false == IsNumber(s_maxsize))
    {
        cout << "* 输入有误，请重新输入：";
        cin >> s_maxsize;
    }
    return atoi(s_maxsize.c_str());
}

//构造顺序队列
template <class T>
SeqQueue<T>* construct_seqqueue()
{
    cout << "\n==> 创建顺序队列" << endl;
    int n_maxsize = get_maxsize<T>();
    SeqQueue<T> *seqQueue = new SeqQueue<T>(n_maxsize);
    return seqQueue;
}

//析构顺序队列
template <class T>
void destory_seqqueue(SeqQueue<T>* seqQueue)
{
    cout << "\n==> 释放顺序队列在堆中申请的空间，并将指向该空间的指针变量置为空" << endl;
    delete seqQueue;
    seqQueue = NULL;
}

//新元素x入队
template <class T>
void enqueue(SeqQueue<T>* seqQueue)
{
    cout << "$ 执行新元素x入队函数" << endl;
    T data = get_data<T>();
    seqQueue->EnQueue(data);
    cout << "* 入队成功，data = " << data << endl;
}

//队头元素出队，并将该元素的值保存至x
template <class T>
void dequeue(SeqQueue<T>* seqQueue)
{
    cout << "$ 执行队头元素出队并将该元素的值保存至x函数" << endl;
    T data;
    if (false == seqQueue->DeQueue(data))
    {
        cout << "* 出队失败" << endl;
        return;
    }
    cout << "* 出队成功，data = " << data << endl;
}

//读取队头元素，并将该元素的值保存至x
template <class T>
void getfront(SeqQueue<T>* seqQueue)
{
    cout << "$ 执行读取队头元素并将该元素的值保存至x函数" << endl;
    T data;
    if (false == seqQueue->getFront(data))
    {
        cout << "* 读取队头元素失败" << endl;
        return;
    }
    cout << "* 读取队头元素成功，data = " << data << endl;
}

//读取队尾元素，并将该元素的值保存至x
template <class T>
void getrear(SeqQueue<T>* seqQueue)
{
    cout << "$ 执行读取队尾元素并将该元素的值保存至x函数" << endl;
    T data;
    if (false == seqQueue->getRear(data))
    {
        cout << "* 读取队尾元素失败" << endl;
        return;
    }
    cout << "* 读取队尾元素成功，data = " << data << endl;
}

//判断队列是否为空
template <class T>
void isempty(SeqQueue<T>* seqQueue)
{
    cout << "$ 执行判断队列是否为空函数，IsEmpty = " << seqQueue->IsEmpty() << endl;
}

//判断队列是否为满
template <class T>
void isfull(SeqQueue<T>* seqQueue)
{
    cout << "$ 执行判断队列是否为满函数，IsFull = " << seqQueue->IsFull() << endl;
}

//计算队列中元素个数
template <class T>
void getsize(SeqQueue<T>* seqQueue)
{
    cout << "$ 执行计算队列中元素个数函数，Size = " << seqQueue->getSize() << endl;
}

//清空队列的内容
template <class T>
void makeempty(SeqQueue<T>* seqQueue)
{
    cout << "$ 执行清空队列的内容函数" << endl;
    seqQueue->MakeEmpty();
}

//输出队列元素的重载操作<<
template <class T>
void operator_ostream(SeqQueue<T>* seqQueue)
{
    cout << "$ 执行输出队列元素的重载操作<<函数" << endl;
    cout << *seqQueue;//或operator<<(cout, *seqQueue);
}

//顺序队列操作选择
template <class T>
void select_operation(SeqQueue<T>* seqQueue)
{
    if (NULL == seqQueue)
    {
        cout << "* 没有构造顺序队列，请先构造顺序队列。" << endl;
        return;
    }

    string s_operation;
    while (s_operation != "0")
    {
        cout << "\n==> 请输入功能选项编号(按\"0\"退出程序)：";
        cin >> s_operation;
        while (false == IsNumber(s_operation))
        {
            cout << "* 输入有误，请重新输入：";
            cin >> s_operation;
        }
        int n_operation = atoi(s_operation.c_str());
        switch (n_operation)
        {
            case EXIT://退出
            {
                cout << "$ 退出程序" << endl;
                break;
            }
            case ENQUEUE://新元素x入队
            {
                enqueue(seqQueue);
                break;
            }
            case DEQUEUE://队头元素出队，并将该元素的值保存至x
            {
                dequeue(seqQueue);
                break;
            }
            case GETFRONT://读取队头元素，并将该元素的值保存至x
            {
                getfront(seqQueue);
                break;
            }
            case GETREAR://读取队尾元素，并将该元素的值保存至x
            {
                getrear(seqQueue);
                break;
            }
            case ISEMPTY://判断队列是否为空
            {
                isempty(seqQueue);
                break;
            }
            case ISFULL://判断队列是否为满
            {
                isfull(seqQueue);
                break;
            }
            case GETSIZE://计算队列元素个数
            {
                getsize(seqQueue);
                break;
            }
            case MAKEEMPTY://清空队列的内容
            {
                makeempty(seqQueue);
                break;
            }
            case OPERATOR_OSTREAM://输出队列元素的重载操作<<
            {
                operator_ostream(seqQueue);
                break;
            }
            default:
            {
                cout << "* 请输入正确的功能选项编号" << endl;
                break;
            }
        }
    }
}

int main(int argc, char* argv[])
{
    print_description();
    SeqQueue<int> *seqQueue = construct_seqqueue<int>();
    select_operation(seqQueue);
    destory_seqqueue(seqQueue);
    system("pause");
    return 0;
}

参考文献：

[1]《数据结构(用面向对象方法与C++语言描述)(第2版)》殷人昆——第三章

[2]《C/C++常用算法手册》秦姣华、向旭宇——第二章

[3]?百度搜索关键字：顺序队列

时间： 2024-08-26 16:30:56

顺序队列(Sequential Queue)的相关文章

数据结构_线性表_顺序队列_循环队列_链队列

个位看官,由于队列操作相对简单,我啥也不多说,直接上代码,欢迎验证!!! #pragma mark --abstract //队列(queue)是只允许在表的一端进行插入,在表的另一端进行删除的线性表,允许插入的一端称为队尾(rear) //允许删除的一端叫做队头(font),不含元素的队列称为空队列 //队列的特点是先进先出(FIFO线性表) #pragma mark --分类 //1.队列的顺序存储结构称为顺序队列(sequential queue),他是由存放队列的一维数组和分别指向队头和

数据结构——顺序队列（sequence queue）

/* sequenceQueue.c */ /* 顺序队列 */ #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define MAXSIZE 100 /* 顺序循环队列数据结构 */ /* 一个圆圈,front指向队列头,rear指向队列尾 */ /* front -> ... -> rear data[0] -> data[...] -> data[n] */ type

数据结构Java实现07----队列：顺序队列&amp;顺序循环队列、链式队列、顺序优先队列

数据结构Java实现07----队列:顺序队列&顺序循环队列.链式队列.顺序优先队列 一.队列的概念: 队列(简称作队,Queue)也是一种特殊的线性表,队列的数据元素以及数据元素间的逻辑关系和线性表完全相同,其差别是线性表允许在任意位置插入和删除,而队列只允许在其一端进行插入操作在其另一端进行删除操作. 队列中允许进行插入操作的一端称为队尾,允许进行删除操作的一端称为队头.队列的插入操作通常称作入队列,队列的删除操作通常称作出队列. 下图是一个依次向队列中插入数据元素a0,a1,...,an-

顺序队列实现任务以此执行-任务调度系列2

顺序队列实现任务以此执行的想法: public class TaskManage { //任务队列 private BlockingQueue<Runnable> queue = new ArrayBlockingQueue<Runnable>(10); private boolean running = false; public void start() { running = true; Thread t = new Thread(new OrderedJob()); t.s

数据结构6_顺序队列（循环队列）

本文实现了顺序队列,与链队列不同的是,顺序队列需要考虑一个问题, 问题情况如下, 解决办法:循环队列,当rear到分配的数组空间末尾时,转到数组头 但是当q.rear==q.front时,又如何区分一种是空队列,一种是满队列的情况呢 这里有两种方案 本次代码实现了第一种方法,同时设置了一个技术变量length,稍加改动便可实现第二个方法 代码如下: #include<iostream>using namespace std;//该顺序队列为循环队列,解决队尾指针达到最大值,队列中有空闲单元,但

【小白成长撸】--循环顺序队列

1 // 循环顺序队列.cpp : 定义控制台应用程序的入口点. 2 //适合整数 3 4 #include "stdafx.h" 5 #include<stdio.h> 6 7 #define MAXNUM 100 8 #define true 1 9 #define false 0 10 11 typedef struct queue_type 12 { 13 int queue[MAXNUM];//队列的最大值为100 14 int front;//头指针 15 in

顺序队列总结

基本数据结构之-顺序队列 顺序队列就是对开辟在堆上的一段连续空间的操作 队列有入队和出队的操作,如果把开始的位置作为队头,那么在入队的时候需要移动数据,如果把末尾做为队头,在出队的时候需要移动元素,所以使用哪种方法都没有简单的, 其实可以指定两个参数来标记队列中队头和对尾的位置,但是在入队和出队的时候就需把这种情况考虑进去.(其实这就成了循环队列了,哈哈) 今天还是写顺序队列吧 //分析需要一个容量(因为需要动态的开辟空间来存储数据) // 需要一个长度来记录当前数据的长度 typedef st

顺序队列和链式队列的实现

队列是一种常用的数据结构,它跟栈一样,操作都受到限制,队列只允许从一端进数据,另一端出数据.队列跟栈不同,栈是一种"后进先出"的模式,而队列是一种"先进先出"的操作模式.就好比日常排队一样,先排队的先出,后排队的后出.例如,进入队列的顺序是1,2,3,4,5则出队列的顺序是1,2,3,4,5(只考虑一次性出列的情况). 队列也分顺序队列和链式队列,跟顺序栈和链表栈一样,顺序队列同样是基于数组实现,链式队列则是基于链表实现. 顺序队列: //顺序队列 #include

【数据结构】顺序队列的实现（c++）

头文件: #pragma once #include <iostream> #include <assert.h> using namespace std; template<class Type> class SeqQueue { public: SeqQueue(size_t sz = INIT_SZ); ~SeqQueue(); public: bool empty()const; bool full()const; void show()const; bool