迴圈佇列ADT陣列實現

• 使用陣列儲存
• 操作集合
  • 入隊
  • 出隊
  • 清空
  • 初始化
  • 返回隊前元素
  • 列印

重點注意！
對於一個迴圈佇列
front == rear時候佇列可能是空可能是滿的
解決方案：
1.使用一個額外變數標記Size表示當前的元素個數或者
Tag(刪除是0 插入是1，當rear==front時候，判斷最後一次操作是1還是0即可判斷是空還是滿)
2.只使用n-1個數組空間

這裡使用第二種實現方案

原始檔

#include <stdio.h>
 

#include <stdlib.h>
typedef int ElementType;

//最大的儲存元素個數
const int MaxSize = 16;

//重點注意！
//對於一個迴圈佇列
//front == rear時候佇列可能是空可能是滿的
//解決方案：
//1.使用一個額外變數標記Size表示當前的元素個數或者
//Tag(刪除是0 插入是1，當rear==front時候，判斷最後一次操作是1還是0即可判斷是空還是滿)
//2.只使用n-1個數組空間

//這裡使用第二種實現方案
//結構體
//陣列實現 迴圈佇列
struct QNode
{
    ElementType *Data;
    int
 
 rear;
    int front;
    int MaxSize;
};

typedef struct QNode *Queue;

#ifndef _Queue_H

//列印
void PrintQ(Queue Q);

//建一個空的隊
Queue CreatQueue(int MaxSize);

//判斷佇列Q是否已經滿了
int IsFullQ(Queue Q, int MaxSize);

//將資料元素item插入到佇列中
void AddQ(Queue Q, ElementType X);

//判斷佇列是否是空的
int IsEmptyQ(Queue Q);

//刪除隊頭元素並且返回
 

ElementType DeleteQ(Queue Q);

#endif // !_Queue_H

int main(int argc, char const *argv[])
{
    Queue Q = nullptr;
    int choose;
    printf("\t\t\tplease intput a int to do something.\n");
    printf("\t\t\t1.push\n");
    printf("\t\t\t2.pop.\n");
    printf("\t\t\t3.isfull?\n");
    printf("\t\t\t4.isempty?\n");
    printf("\t\t\t5.show.\n");
    Q = CreatQueue(MaxSize);
    int num;
    while (~scanf("%d", &choose))
    {
        if (choose == 0)
        {
            break;
        }

        switch (choose)
        {
        case 1:
            printf("\t\t\tinput a int.\n");
            scanf("%d", &num);
            AddQ(Q, num);
            PrintQ(Q);
            break;

        case 2:
            printf("the front element is %d\n", DeleteQ(Q));
            PrintQ(Q);
            break;

        case 3:
            if (IsFullQ(Q,Q->MaxSize))
                printf("full!\n");
            else
                printf("not yet.\n");
            break;

        case 4:
            if(IsEmptyQ(Q))
            {
                printf("it is empty.\n");
            }
            else
            {
                printf("no yet.\n");
            }
            break;

        case 5:
            PrintQ(Q);
            break;
        }
    }
    system("pause");
    return 0;
}

//建一個空的隊
Queue CreatQueue(int MaxSize)
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->Data = (ElementType *)malloc(sizeof(ElementType) * MaxSize);
    Q->rear = Q->front = 0;
    Q->MaxSize = MaxSize;
    return Q;
}

//判斷佇列Q是否已經滿了
int IsFullQ(Queue Q, int MaxSize)
{
    return ((Q->rear + 1) % Q->MaxSize == Q->front);
}

//將資料元素item插入到佇列中
void AddQ(Queue Q, ElementType X)
{
    if ((Q->rear + 1) % Q->MaxSize == Q->front)
    {
        printf("full queue.\n");
        return;
    }
    //插入後rear向後挪動一個位置
    Q->rear = (Q->rear + 1) % Q->MaxSize;
    Q->Data[Q->rear] = X;
}

//判斷佇列是否是空的
int IsEmptyQ(Queue Q)
{
    return Q->rear == Q->front;
}

//刪除隊頭元素並且返回
ElementType DeleteQ(Queue Q)
{
    if (IsEmptyQ(Q))
    {
        printf("queue is empty.\n");
        return -1;
    }
    else
    {
        Q->front = (Q->front + 1) % Q->MaxSize;
        return Q->Data[Q->front];
    }
}

//列印
void PrintQ(Queue Q)
{
    if (Q->rear < Q->front)
    {
        for (int i = Q->front; i <= Q->MaxSize - 1; i++)
        {
            printf("%d-", Q->Data[i]);
        }
        for (int i = 0; i <= Q->rear; i++)
        {
            printf("%d-", Q->Data[i]);
        }
    }
    else
    {
        for (int i = Q->front + 1; i <= Q->rear; i++)
        {
            printf("%d-", Q->Data[i]);
        }
    }
    putchar('\n');
}