数据结构与算法——队列（顺序存储）

 

队列 (Queue)概念

它是一种运算受限的线性表,先进先出(FIFO First In First Out)，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。

采用数组来保存队列的元素，设立一个队首指针 front ，一个队尾指针 rear，分别指向队首和队尾元素。则 rear-front 即为存储的元素个数！

#define MaxSize 5                //队列的最大容量 
typedef int DataType;            //队列中元素类型

typedef struct Queue
{
    DataType queue[MaxSize];
    int front;                   //队头指针 
    int rear;                    //队尾指针
}SeqQueue;

 

队列的初始化

//队列初始化，将队列初始化为空队列
void InitQueue(SeqQueue* SQ)
{
    if (!SQ) return;
    SQ->front = SQ->rear = NULL; //把对头和队尾指针同时置0
}

 

队列为空

//判断队列为空
int IsEmpty(SeqQueue* SQ)
{
    if (!SQ) return 0;
    if (SQ->front == SQ->rear)
    {
        return 1;
    } return 0;
}

 

队列为满

//判断队列是否为满
int IsFull(SeqQueue *SQ)
{ if(!SQ) return 0;
if (SQ->rear == MaxSize)
{ return 1;
} return 0;
}

 

入队

将新元素插入 rear 所指的位置，然后 rear 加 1。

//入队,将元素data插入到队列SQ中
int EnterQueue(SeqQueue* SQ, DataType data)
{
    if (!SQ) return 0;
    if (IsFull(SQ))
    {
        cout << "无法插入元素 " << data << ", 队列已满!" << endl; return 0;
    }
    SQ->queue[SQ->rear] = data; 　　//在队尾插入元素data 
    SQ->rear++;                    //队尾指针后移一位

    return 1;
}

 

打印队列中的元素

void PrintQueue(SeqQueue* SQ)
{
    if (!SQ) return;
    int i = SQ->front; while (i < SQ->rear)
    {
        cout << setw(4) << SQ->queue[i]; i++;
    }
    cout << endl;
}

 

出队方式一

删除 front 所指的元素, 后面所有元素前移 1 并返回被删除元素

int DeleteQueue(SeqQueue * SQ, DataType * data) 
{
    if (!SQ || IsEmpty(SQ)) 
    {
        cout << "队列为空！" << endl;
        return 0;
    } if (!data) return 0;
    *data = SQ->queue[SQ->front];
    for (int i = SQ->front + 1; i < SQ->rear; i++) 
    {
        //移动后面的元素 
        SQ->queue[i-1]=SQ->queue[i];
    }
    SQ->rear--;                    //队尾指针前移一位 
    return 1;
}

 

出队方式二

删除 front 所指的元素，然后加 1 并返回被删元素。

int DeleteQueue2(SeqQueue * SQ, DataType * data)
{
    if (!SQ || IsEmpty(SQ))
    {
        cout << "队列为空！" << endl;
        return 0;
    }
    if (SQ->front >= MaxSize) {
        cout << "队列已到尽头!" << endl;
        return 0;
    }
    *data = SQ->queue[SQ->front];    //出队元素值 
    SQ->front = (SQ->front)+1;    　　//队首指针后移一位 
    return 1;
}

 

 

取队首元素

返回 front 指向的元素值

int GetHead(SeqQueue* SQ, DataType* data)
{
    if (!SQ || IsEmpty(SQ))
    {
        cout << "队列为空!" << endl;
    }
    return *data = SQ->queue[SQ->front];
}

 

清空队列

void ClearQueue(SeqQueue* SQ)
{
    if (!SQ) return;
    SQ->front = SQ->rear = 0;
}

 

 获取队列中元素的个数

int getLength(SeqQueue* SQ) 
{
    if (!SQ) return 0;
    return SQ->rear - SQ->front;
}

 

 

完整代码实现

#include <stdio.h>
#include <assert.h>
#include <Windows.h>
#include <iostream> 
#include <iomanip> 

using namespace std;

#define MaxSize 5            //队列的最大容量 
typedef int DataType;        //队列中元素类型

typedef struct Queue
{
    DataType queue[MaxSize];
    int front;                //队头指针 
    int rear;                //队尾指针
}SeqQueue;


//队列初始化，将队列初始化为空队列
void InitQueue(SeqQueue* SQ)
{
    if (!SQ) return;
    SQ->front = SQ->rear = 0; //把对头和队尾指针同时置0
}

//判断队列为空
int IsEmpty(SeqQueue* SQ)
{
    if (!SQ) return 0;
    if (SQ->front == SQ->rear)
    {
        return 1;
    } return 0;
}

//判断队列是否为满
int IsFull(SeqQueue* SQ)
{
    if (!SQ) return 0;
    if (SQ->rear == MaxSize)
    {
        return 1;
    } return 0;
}

//入队,将元素data插入到队列SQ中
int EnterQueue(SeqQueue* SQ, DataType data)
{
    if (!SQ) return 0;
    if (IsFull(SQ))
    {
        cout << "无法插入元素 " << data << ", 队列已满!" << endl; return 0;
    }
    SQ->queue[SQ->rear] = data; //在队尾插入元素data 
    SQ->rear++;                    //队尾指针后移一位

    return 1;
}

//打印队列中的各元素
void PrintQueue(SeqQueue* SQ)
{
    if (!SQ) return;
    int i = SQ->front; while (i < SQ->rear)
    {
        cout << setw(4) << SQ->queue[i]; i++;
    }
    cout << endl;
}

//出队，将队列中队头的元素data出队，后面的元素向前移动
int DeleteQueue(SeqQueue * SQ, DataType * data) 
{
    if (!SQ || IsEmpty(SQ)) 
    {
        cout << "队列为空！" << endl;
        return 0;
    } if (!data) return 0;
    *data = SQ->queue[SQ->front];
    for (int i = SQ->front + 1; i < SQ->rear; i++) 
    {
        //移动后面的元素 
        SQ->queue[i-1]=SQ->queue[i];
    }
    SQ->rear--;                    //队尾指针前移一位 
    return 1;
}

//出队2，将队列中队头的元素data出队，出队后队头指针front后移一位
int DeleteQueue2(SeqQueue * SQ, DataType * data)
{
    if (!SQ || IsEmpty(SQ))
    {
        cout << "队列为空！" << endl;
        return 0;
    }
    if (SQ->front >= MaxSize) {
        cout << "队列已到尽头!" << endl;
        return 0;
    }
    *data = SQ->queue[SQ->front];    //出队元素值 
    SQ->front = (SQ->front)+1;    //队首指针后移一位 
    return 1;
}

//获取队首元素，返回 front 指向的元素值
int GetHead(SeqQueue* SQ, DataType* data)
{
    if (!SQ || IsEmpty(SQ))
    {
        cout << "队列为空!" << endl;
    }
    return *data = SQ->queue[SQ->front];
}

//清空队列
void ClearQueue(SeqQueue* SQ)
{
    if (!SQ) return;
    SQ->front = SQ->rear = 0;
}

//获取队列中元素的个数
int getLength(SeqQueue* SQ) {
    if (!SQ) return 0;
    return SQ->rear - SQ->front;
}

int main()
{
    SeqQueue* SQ = new SeqQueue;
    DataType data = -1;

    //初始化队列
    InitQueue(SQ);

    //入队
    for (int i = 0; i < 7; i++) 
    {
        EnterQueue(SQ, i);
    }

    //打印队列中的元素    11
    printf("队列中的元素(总共%d 个)：", getLength(SQ));

    PrintQueue(SQ); 
    cout << endl;

    ////出队
    //for(int i=0; i<10; i++)
    //{ 
    //    if(DeleteQueue2(SQ, &data))
    //    { 
    //        cout<<"出队的元素是："<<data<<endl;    
    //    }
    //    else 
    //    {
    //        cout << "出队失败！" << endl;
    //    }
    //}

    //打印队列中的元素 
    printf("出队一个元素后，队列中剩下的元素：");
    PrintQueue(SQ); 
    cout << endl;
    system("pause"); 
    return 0;
}

 

 

 

 

===================================================================================================================