数据结构与算法分析c语言描述（Mark Allen）--队列ADT链表实现

队列ADT链表实现

---

• 使用链表存储
• 操作集合

  • 入队

  • 出队

  • 初始化

  • 返回队前元素

  • 打印

---

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

typedef int ElementType;
struct Node
{
    ElementType Data;
    struct Node *Next;
};

//链队列结构
struct QNode
{
    struct Node *rear;  //尾部指针
    struct Node *front; //头部指针
    int size;
};
typedef struct QNode *Queue;
Queue PtrQ;

ElementType DeleteQ(Queue PtrQ);
void addQ(Queue PtrQ, ElementType x);
bool IsEmpty(Queue Q);
void PrintQ(Queue PtrQ);
ElementType GetHead(Queue Q);
void MakeQ(Queue PtrQ);

int main(int argc, char const *argv[])
{
    PtrQ=(Queue)malloc(sizeof(struct QNode));
    int choose;
    MakeQ(PtrQ);
    printf("\t\t\t1.print queue.\n");
    printf("\t\t\t2.dequeue.\n");
    printf("\t\t\t3.enqueue.\n");

    printf("\t\t\t4.get front.\n");
    while (~scanf("%d", &choose))
    {
        if (choose == 0)
        {
            break;
        }

        switch (choose)
        {
        case 1:

            PrintQ(PtrQ);
            printf("-------------\n");
            break;

        case 2:

            printf("delete the front num and it is %d\n", DeleteQ(PtrQ));
            break;

        case 3:

            int x;
            printf("\t\t\tinput a element.\n");
            scanf("%d", &x);
            addQ(PtrQ, x);
            break;

        case 4:

            printf("front =  %d\n", GetHead(PtrQ));
            break;
        }
    }
    system("pause");
    return 0;
}


void MakeQ(Queue PtrQ)
{
    PtrQ->front = (Node *)malloc(sizeof(struct Node));
    if (!PtrQ->front)
    {
        printf("overflow.\n");
        return;
    }
    PtrQ->size = 0;
    PtrQ->rear = PtrQ->front;
    PtrQ->front->Next = nullptr;
}

void PrintQ(Queue PtrQ)
{
    Node *f = PtrQ->front->Next;
    int tag = 0;
    for (; f != nullptr; f = f->Next)
    {
        if (tag == 0)
        {
            tag = 1;
        }
        else
        {
            printf("->");
        }
        printf("%d", f->Data);
    }
    printf("->null\n");
}

ElementType DeleteQ(Queue PtrQ)
{
    if(PtrQ->front==PtrQ->rear)
    {
        printf("empty!\n");
        return -1;
    }
    struct Node *FrontCell;
    ElementType FrontElem;

    if (PtrQ->front == nullptr || PtrQ->front->Next == nullptr)
    {
        printf("empty queue.\n");
        return -10086;
    }
    PtrQ->size--;
    FrontCell = PtrQ->front->Next;
    //只剩下一个元素
    if (PtrQ->front == PtrQ->rear)
    {
        PtrQ->front = PtrQ->rear = nullptr;
    }
    else
    {
        PtrQ->front->Next = PtrQ->front->Next->Next;
    }

    FrontElem = FrontCell->Data;
    free(FrontCell); //释放被删除的节点空间
    return FrontElem;
}

bool IsEmpty(Queue Q)
{
    return (Q->front == nullptr);
}

void addQ(Queue PtrQ, ElementType x)
{
    Node *p = (Node *)malloc(sizeof(struct Node));
    if (!p)
    {
        printf("overflow.\n");
        return;
    }
    PtrQ->size++;
    p->Data = x;
    p->Next = nullptr;
    PtrQ->rear->Next = p;
    PtrQ->rear = p;
}
ElementType GetHead(Queue Q)
{
    if (Q->rear == Q->front)
    {
        printf("overflow.\n");
        return -10086;
    }
    return Q->front->Next->Data;
}