数据结构-3.5.队列的顺序实现

一.队列的顺序实现，初始化操作以及判断队列是否为空：

1.图解：

2.代码：

#include<stdio.h>
#define MaxSize 10 //定义一个队列最多存储的元素个数 

typedef struct
{
    int data[MaxSize]; //用静态数组存放队列元素
    int front; //队头指针,队头删除元素 
    int rear; //队尾指针,队尾插入元素 
}SqQueue; 

//初始化队列
void InitQueue(SqQueue &Q)
{
    //初始时，队头和队尾指针都指向0 
    Q.front=0;//对头一开始就为0即第一个位置 
    Q.rear=0;//队尾指针指向下一个插入元素的位置，一开始没元素，下一个当然插在第一个位置即0索引处 
} 

//判断队列是否为空
bool QueueEmpty(SqQueue Q)
{
    if( Q.rear==Q.front ) //Q.rear==Q.front为队空条件 
    {
        return true; //代表队列为空 
    }
    else
    {
        return false; //代表队列不为空 
    } 
} 

int main()
{
    SqQueue Q; //声明一个队列(顺序存储)
    InitQueue(Q);
    //后续操作。。。 
    return 0;
}

二.队尾元素入队操作(添加数据元素)：

1.图解：

a.判断队列是否已满：

b.举例，假设队尾指针指向9：

c.添加元素后：

d.队尾指针进行Q.rear = (Q.rear+1)%MaxSize操作后：对队列最大存储空间取模求出还能存几个元素

e.由于对队尾指针进行的操作是取余运算，会不断地从上到下的循环(比如除以3，余数只会是0,1,2)，因此形成了一个闭环：

f.上述就是一个循环队列，循环队列还可以解决如下的队列假溢出的情况：

g.继续刚才的例子，此时还有空闲的空间，因此可以继续插入新的数据元素：

h.同时需要队尾指针不断的后移：

i.当队列只剩最后一个存储空间时，就认为此时队列已经满了：

可能会问，此时不是还剩一个存储空间吗，为什么认为满了呢，但需要注意的是，初始化队列时，队头指针和队尾指针是指向了同一个位置，因此判断是否队列已经满了，也需要看队头指针和队尾指针是否指向了同一个位置

(注：队尾指针指向下一个插入元素的位置)

j.总结：

2.代码：

#include<stdio.h>
#define MaxSize 10 //定义一个队列最多存储的元素个数 

typedef struct
{
    int data[MaxSize]; //用静态数组存放队列元素
    int front; //队头指针,队头删除元素 
    int rear; //队尾指针,队尾插入元素 
}SqQueue; 

//初始化队列
void InitQueue(SqQueue &Q)
{
    //初始时，队头和队尾指针都指向0 
    Q.front=0;//对头一开始就为0即第一个位置 
    Q.rear=0;//队尾指向下一个插入元素的位置，一开始没元素，下一个当然插在第一个位置即0索引处 
} 

//判断队列是否为空
bool QueueEmpty(SqQueue Q)
{
    if( Q.rear==Q.front ) //Q.rear==Q.front为队空条件 
    {
        return true; //代表队列为空 
    }
    else
    {
        return false; //代表队列不为空 
    } 
} 

//入队
bool EnQueue(SqQueue &Q,int x)
{
    if( (Q.rear+1)%MaxSize==Q.front )
    {
        return false;//此时队满,返回false 
    }
    //此时队没满
    Q.data[ Q.rear ] = x; 
    /*新元素插入队尾,应该插在Q.rear处,
    因为Q.rear队尾指针指向下一个插入元素的位置,而新插入的x刚好就要在
    下一个插入元素的位置*/
    Q.rear = (Q.rear+1)%MaxSize; //队尾指针加一取模 
    return true;
} 

int main()
{
    SqQueue Q; //声明一个队列(顺序存储)
    InitQueue(Q);
    //后续操作。。。 
    return 0;
}

三.队头元素出队操作(删除数据元素)：

1.图解：

注：这里x有&，调用完函数后x也就跟着改变了，x就是被删除的那个元素，队头指针后移就相当于删除了一个元素：

a.Q.front = (Q.front+1)%MaxSize，也需要对MaxSize取模,这样才能让front循环移动：

b.每次出队的都是front指针所指向的元素即x = Q.data[Q.front]，并且队头指针会向后移一位：

c.当队头指针和队尾指针再次指向同一个位置时，此时队列已经被取空，此时不能再进行出队操作：

2.代码：

#include<stdio.h>
#define MaxSize 10 //定义一个队列最多存储的元素个数 

typedef struct
{
    int data[MaxSize]; //用静态数组存放队列元素
    int front; //队头指针,队头删除元素 
    int rear; //队尾指针,队尾插入元素 
}SqQueue; 

//出队(删除一个队头元素,并用x返回)
bool DeQueue(SqQueue &Q,int &x) //这里x有&，调用完函数后x也就跟着改变了 
{
    if( Q.rear==Q.front ) //首先要判断队列是否为空，因为空队列无法删除元素 
    {
        return false; //此时队列为空 
    }
    //此时队列不为空
    x = Q.data[Q.front];//把队头指针指向的元素赋值给变量x 
    Q.front = (Q.front+1)%MaxSize;//队头指针后移一位,也需要对MaxSize取模,这样才能让front循环移动 
    return true; 
} 

int main()
{
    return 0;
}

四.查找队列中的元素：

1.图解：

通常只需要查询或者只需要读取队列中队头的元素：

获得队头元素的值即查找元素，用x返回。这里x有&，调用完函数后x也就跟着改变了,变为队头元素； x就是队头元素，获取到队头元素后可以与要查找的元素比较。

2.代码：

#include<stdio.h>
#define MaxSize 10 //定义一个队列最多存储的元素个数 

typedef struct
{
    int data[MaxSize]; //用静态数组存放队列元素
    int front; //队头指针,队头删除元素 
    int rear; //队尾指针,队尾插入元素 
}SqQueue; 

//获得队头元素的值即查找元素，用x返回
/*这里x有&，调用完函数后x也就跟着改变了,变为队头元素； 
  x就是队头元素，获取到队头元素后可以与要查找的元素比较*/
  //相比出队操作，就少了一个Q.front = (Q.front+1)%MaxSize，就不让队头指针后移 
bool GetHead(SqQueue Q,int &x)
{
    if( Q.rear==Q.front )//需要判断队列是否为空，空队列无法查找元素 
    {
        return false;//队空返回false 
    }
    //此时队列不为空
    x = Q.data[Q.front];
    return true; 
}

int main()
{
    return 0;
}