计算机考研——队列的顺序实现伪代码

队列的定义和初始化操作

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

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

队列判空

// 判空
bool QueueEmpty(SqQueue 0){
    if(Q.rear == Q.front)    //判空条件后
        return true;
    else 
        return false;
}

循环队列

a%b == a除以b的余数

初始：Q.front = Q.rear = 0;

队首指针进1：Q.front = (Q.front + 1) % MaxSize

队尾指针进1：Q.rear = (Q.rear + 1) % MaxSize —— 队尾指针后移，当移到最后一个后，下次移动会到第一个位置

队列长度：(Q.rear + MaxSize - Q.front) % MaxSize

方案一: 牺牲一个单元来区分队空和队满

循环队列——入队

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

    return true;
}

循环队列——出队

//出队，删除一个队头元素，用x返回
bool DeQueue(SqQueue &Q, ElemType &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, ElemType &x){
    if(Q.rear == Q.front)              //队空报错
        return false;  

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

方案二：设置size，队列元素个数=size

队满条件：size == MaxSize

队空条件：size == 0

队列的定义和初始化

# define MaxSize 10;     
typedef struct{
    ElemType data[MaxSize];   
    int front, rear;        
    int size;               //队列当前长度
}SqQueue;

//初始化队列
void InitQueue(SqQueue &Q){
    Q.rear = Q.front = 0;
    size = 0;
}

 队列判空

//判断队列是否为空 
bool Queueempty(SqQueue q){
    if(q.size==0)
        return true;
    else
        return false;;
}

循环队列——入队

//循环队列——入队操作
bool EnQueue(SqQueue &q,int x){
    if(q.size==Maxsize) 
        return false;           //队满则报错
    q.data[q.rear]=x;           //新元素插入队尾
    q.rear=(q.rear+1)%Maxsize;  //队尾指针加1取模
    q.size++;
    return true;
}

循环队列——出队

//循环队列——出队操作（删除一个队头元素，并用e返回）
bool DeQueue(SqQueue &q,int &e){
    if(q.size==0) 
        return false;   //队空则报错
    e=q.data[q.front];
    q.front=(q.front+1)%Maxsize;
    q.size--;
    return true;
}

方案三：设置tag，初始设置tag=0

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

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

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

队列的定义和初始化

typedef struct LinkNode{      //链式队列结点
    ElemType data;
    struct LinkNode *next;
}

typedef struct{               //链式队列
    LinkNode *front, *rear;   //队列的队头和队尾指针
}LinkQueue;

队列判空

bool Queueempty(SqQueue q){
    if(q.tag==0&&q.front==q.rear)
        return true;
    else
        return false;;
}

循环队列——入队

//循环队列——入队操作
bool EnQueue(SqQueue &q,ElemType x){
    if(q.tag==1&&q.front==q.rear) 
        return false;           //队满则报错
    q.data[q.rear]=x;           //新元素插入队尾
    q.rear=(q.rear+1)%Maxsize;  //队尾指针加1取模
    q.tag=1;
    return true;
}

循环队列——出队

//循环队列——出队操作（删除一个队头元素，并用e返回）
bool DeQueue(SqQueue &q,int &e){
    if(q.tag==0&&q.rear==q.front) 
        return false;   //队空则报错
    e=q.data[q.front];
    q.front=(q.front+1)%Maxsize;
    q.tag=0;
    return true;
}