基本数据结构，循环队列的顺序实现。

队列是一种先进先出的数据结构，这里用顺序结构将其实现。

1.首先用结构体定义一个队列，front指向队首元素的前面一位，real指向队尾元素。

//队列的结构定义
#define MAX 6
typedef struct {
    int front,real;
    int data[MAX];
}queue;

2.创建一个循环队列，初始化令front=real=0，因为当队列满时也有front=real，此时无法判断队满；所以我们弃置一个元素位不用，其位置随机，所以队列的实际最大容量为MAX-1。

//队列的初始化
void InitQueue(queue *s)
{
    s->front=s->real=0; 
}

2.入队操作,首先判断队列是否满，此时可能有两种情况：一种是队尾指针到达队首指针的前面一个位置，此时判断条件是  s->real+1==s->front；另一种情况是队尾指针到达该队列的最后一个位置，此时就不能用s->real+1==s->front来判断了，这时可以通过(s->real+1)%MAX==s->front来判断是否队满。若队列不满，则指针下移，下移思路和判断队满一样，移动条件为s->real = (s->real+1)%(MAX)，同时给队尾元素赋值。

//入队
void EnQueue(queue *s,int e){
    if((s->real+1)%MAX==s->front){
        printf("队列上溢\n");
        return ;
    }
    s->real = (s->real+1)%(MAX);    
    s->data[s->real] = e;
} 

 3.判断队空

//队列空返回1，不为空返回0。
int EmptyQueue(queue *s){
    if(s->front==s->real){
        return 1;
    }
    return 0;
} 

4.出队操作，如果队列下溢，则函数返回；否则将队首指针后移一位，下移思路和上面一致，都是通过取模运算实现。

void DeQueue(queue *s){
    if(EmptyQueue(s)){
        printf("队列下溢\n");
        return ;
    }
    s->front=(s->front+1)%MAX;
} 

 

链表实现先进先出队列

 

public class Queue<Item> {

    private Node first;    //队头节点
    private Node last;    //队尾节点
    private int N;  //元素个数
    //节点定义
    private class Node{
        Item item;
        Node next;
    }
    
    public boolean isEmpty(){ return first == null; }
    
    public int size(){ return N;}
    
    //入队操作
    public void enqueue( Item item){
        Node oldlast = last;
        last = new Node();
        last.item = item;
        last.next = null;
        if(isEmpty()) first = last;
        else oldlast.next = last;
        N++;
    }
    
    //出队操作
    public Item dequeue(){
        Item item = first.item;
        first = first.next;
        if(isEmpty()) last = null;
        N--;
        return item;
    }
    

}