隊列（循環隊列和鏈隊）

順序隊列一般實現為循環隊列，因為普通的隊列可能產生“假溢出”。

struct SqQueue{
    int data[maxSize];
    int front;
    int rear;
};

循環隊列的兩個狀態：

1.隊空

qu.rear == qu.front

2.隊滿  (注意，循環隊列必須損失一個存儲空間，用來區分隊空和堆滿，如果隊列中的所有空間對被占滿，那么隊空和隊滿的狀態都是qu.front == qu.rear，導致無法區分)

(qu.rear+1)%maxSize == qu.front

循環隊列的兩個操作：

1.進隊

qu.rear = (qu.rear+1)%maxSize     //  先移動指針，再存儲元素
qu.data[qu.rear] = x;

2.出隊

x = qu.data[qu.front];              //  先取元素，再移動指針
qu.front = (qu.front+1)%maxSize;

相關操作：

void InitQueue(SqQueue &qu)
{
    qu.front = qu.rear = 0;
}

int QueueEmpty(SqQueue qu)
{
    if(qu.front==qu.rear)
        return 1;
    else
        return 0;
}

int enQueue(SqQueue &qu,int x)
{
    if((qu.rear+1)%maxSize == qu.front)  // 若隊滿，就不可再添加了
        return 0;
    qu.rear = (qu.rear+1)%maxSize;   // 先移動指針，在存入元素
    qu.data[qu.rear]=x;
    return 1;
}

int deQueue(SqQueue &qu,int &x)
{
    if(qu.front == qu.rear)    // 若隊空，就不可以刪除了
        return 0;
    x = qu.data[qu.front];            // 先取出元素，再移動指針
    qu.front = (qu.front+1)%maxSize;
    return 1;
}

還有一個計算循環隊列中實際元素個數的式子：

 n = (qu.rear - qu.front + maxSize) % maxSize;

 

鏈隊

兩個狀態：

1.隊空

lqu->rear == NULL 或 lqu->front == NULL

2.隊滿

不存在隊滿的情況。

兩個操作：

1.進隊 (假設p指向進隊元素)

lqu->rear->next = p;
lqu->rear = p;

2.出隊 (假設p指向出隊元素，也就是隊首元素)

p = lqu->front;
lqu->front = p->next;
x = p->data;
free(p);

 

相關操作：

//先定義結點
struct QNode{
    int data;
    QNode *next;
};
// 定義鏈隊
struct LQueue
{
    QNode *front;
    QNode *rear;
};

void Init(LQueue *&lqu)
{
    lqu = new LQueue;
    lqu->front = lqu->rear = NULL;
}

int QueueEmpty(LQueue *lqu)
{
    if(lqu->front == NULL||lqu->rear == NULL)
        return 1;
    else 
        return 0;
}

void enQueue(LQueue *&lqu,int x)
{
    QNode *p = new QNode;
    p->data = x;
    p->next = NULL;
    if(lqu->rear == NULL)
        lqu->front = lqu->rear = p;
    else{
        lqu->rear->next = p;
        lqu->rear = p
    }
}

int deQueue(LQueue *&lqu,int &x)
{
    QNode *p;
    if(lqu->rear == NULL)
        return 0;
    else
        p=lqu->front;

    if(lqu->front == lqu->rear)      // 當鏈隊中只有一個結點時，特殊處理
        lqu->front=lqu->rear=NULL;
    else
        lqu->front = lqu->front->next;
    x=p->data;
    free(p);
    return 1;
}