数据结构---实现队列的三种形式

方案一: 牺牲一个单元来区分队空和队满队尾指针的再下一个位置就是队头，即 (Q.rear+1)%MaxSize == Q.front

队满:(Q.rear+1)%MaxSize == Q.front

队空:Q.rear == Q.front

#include<stdio.h>
#include<stdlib.h>

# define MaxSize 10    //定义队列中元素的最大个数
typedef struct {
    int data[MaxSize];   //用静态数组存放队列元素
    //连续的存储空间，大小为——MaxSize*sizeof(ElemType)
    int front, rear;          //队头指针和队尾指针
}SqQueue;

void InitQueue(SqQueue& Q) {
    //初始化时,队头，队尾指针指向0
    Q.rear = Q.front = 0;
}

//判空
bool QueueEmpty(SqQueue Q)
{
    if (Q.rear == Q.front) //判空条件后
        return true;
    else
        return false;
}
/*
牺牲一个单元来区分队空和队满队尾指针的再下一个位置就是队头，
即 (Q.rear+1)%MaxSize == Q.front
*/

bool EnQueue(SqQueue& Q, int x)
{
    if ((Q.rear + 1) % MaxSize == Q.front) //队满
        return false;
    Q.data[Q.rear] = x;  //将x插入队尾
    Q.rear = (Q.rear + 1) % MaxSize; //队尾指针加1取模
 
}

//出队，删除一个队头元素,用x返回
bool DeQueue(SqQueue& Q, int& x) {
    if (Q.rear == Q.front)
        return false;

    x = Q.data[Q.front];
    Q.front = (Q.front + 1) % MaxSize; //队头指针后移动

    return true;
}

//循环队列 --获取队头元素

bool GetHead(SqQueue& Q, int& x) {
    if (Q.rear == Q.front)  //队空报错
        return false;

    x = Q.data[Q.front]; //获取队头元素
    return true;
}

int main() {
    SqQueue    Q;
    int i;
    i = 3;
    InitQueue(Q);
    EnQueue(Q, 1);
    EnQueue(Q, 2);
    EnQueue(Q, 10);


    GetHead(Q, i);
    printf("i = %d", i);
}

方案二: 不牺牲存储空间，设置size

定义一个变量 size用于记录队列此时记录了几个数据元素，初始化 size = 0，进队成功 size++，出队成功size--，根据size的值判断队满与队空

队满条件：size == MaxSize

队空条件：size == 0

#include<stdio.h>
#include<stdlib.h>

/*
方案二: 不牺牲存储空间，设置size**定义一个变量 `size`
用于记录队列此时记录了几个数据元素，初始化 `size = 0`，进队成功 `size++`，
出队成功`size--`，根据size的值判断队满与队空

队满条件：`size == MaxSize`

队空条件：`size == 0`
*/
# define MaxSize 10;     
typedef struct {
    int data[10];
    int front, rear;
    int size;               //队列当前长度
}SqQueue;

//初始化队列
void InitQueue(SqQueue& Q) {  //初始化 `size = 0`，进队成功 `size++`
    Q.rear = Q.front = 0;
     Q.size = 0;
}

//入队
bool EnQueue(SqQueue& Q, int x) {
    if (Q.size == 10)        //队满
        return false;
    Q.data[Q.rear] = x;                      //将x插入队尾
    Q.size++ ;         //队尾指针加1取模

    return true;
}

//出队，删除一个队头元素，用x返回
bool DeQueue(SqQueue& Q, int & x) {
    if (Q.size == 10)              //队空报错
        return false;

    x = Q.data[Q.front];
    Q.size--; //队头指针后移动

    return true;
}

bool GetHead(SqQueue& Q, int & x) {
    if (Q.size == 10)              //队空报错
        return false;

    x = Q.data[Q.front];
    return true;
}

int main() {
    SqQueue    Q;
    int i;
    i = 3;
    InitQueue(Q);
    EnQueue(Q, 1);
    EnQueue(Q, 2);
    EnQueue(Q, 10);
    EnQueue(Q, 4);
    EnQueue(Q, 5);
    GetHead(Q, i);
    printf("i = %d", i);
}

方案三: 不牺牲存储空间，设置tag 定义一个变量 tag，tag = 0 表示最近进行的是删除操作；tag = 1 表示最近进行的是插入操作；

每次删除操作成功时，都令tag = 0；只有删除操作，才可能导致队空； 每次插入操作成功时，都令tag = 1；只有插入操作，才可能导致队满；

队满条件：Q.front == Q.rear && tag == 1

队空条件：Q.front == Q.rear && tag == 0

#include<stdio.h>
#include<stdlib.h>

/*
方案三: 不牺牲存储空间，设置tag
定义一个变量 tag，tag = 0 --最近进行的是删除操作；tag = 1 --最近进行的是插入操作；

每次删除操作成功时，都令tag = 0；只有删除操作，才可能导致队空；
每次插入操作成功时，都令tag = 1；只有插入操作，才可能导致队满；
队满条件：Q.front == Q.rear && tag == 1

队空条件：Q.front == Q.rear && tag == 0
*/

# define MaxSize 10 
typedef struct {
    int data[MaxSize];
    int front, rear;
    int tag;               //最近进行的是删除or插入
}SqQueue;

void InitQueue(SqQueue& Q) {  //初始化 `size = 0`，进队成功 `size++`
    Q.rear = Q.front = 0;
    Q.tag = 0;
}
//入队
bool EnQueue(SqQueue& Q, int x) {
    if ((Q.front == Q.rear) && (Q.tag == 1))        //队满
        return false;
    Q.data[Q.rear] = x;                      //将x插入队尾
    Q.tag = 1;     // tag = 1 --最近进行的是插入操作

    return true;
}

//出队，删除一个队头元素，用x返回
bool DeQueue(SqQueue& Q, int& x) {
    if (Q.front == Q.rear && Q.tag == 0)              //队空报错
        return false;

    x = Q.data[Q.front];
    Q.tag = 0; //tag = 0 --最近进行的是删除操作

    return true;
}

bool GetHead(SqQueue& Q, int& x) {
    if (Q.front == Q.rear && Q.tag == 0)              //队空报错
        return false;

    x = Q.data[Q.front];
    return true;
}

int main() {
    SqQueue    Q;
    int i;
    i = 3;
    InitQueue(Q);
    EnQueue(Q, 1);
    EnQueue(Q, 2);
    EnQueue(Q, 10);
    
    
    GetHead(Q, i);
    printf("i = %d", i);
}

参考文献：

http://t.csdn.cn/vSkfg