数据结构复习代码——链队基本操作的实现

1、链队基本操作的实现

#include<stdio.h>
#include<assert.h>
#include<malloc.h>

#define EType int
typedef struct QueueNode        //队列节点结构体
{
    EType data;              //节点数据域
    struct QueueNode *next;     //节点指针域
}QueueNode;

typedef struct LinkQueue{       //队列结构体
    QueueNode *front;           //队列头指针
    QueueNode *tail;            //队列尾指针
}LinkQueue;

void InitQueue(LinkQueue *Q);                   //队列初始化
void EnQueue(LinkQueue *Q,EType x);          //入队操作
void ShowQueue(LinkQueue *Q);                   //输出队列---简单遍历队列
void DeQueue(LinkQueue *Q);                     //出队操作--头结点出队
EType GetHead(LinkQueue *Q);                 //获取队列首元素
int Length(LinkQueue *Q);                       //获取当前队列长度
void ClearQueue(LinkQueue *Q);                  //逐个清除队列节点
void DestroyQueue(LinkQueue *Q);                //摧毁队列
bool QueueIsEmpty(LinkQueue *Q);                //判空


void InitQueue(LinkQueue *Q)    //队列初始化
{
    QueueNode *s = (QueueNode*)malloc(sizeof(QueueNode));       //为头结点分配内存空间
    assert(s!=NULL);
    Q->front = Q->tail = s;     //初始化头尾指针
    s->next = NULL;             //设置头结点指针
}

void EnQueue(LinkQueue *Q,EType x)       //入队操作
{
    QueueNode *s = (QueueNode*)malloc(sizeof(QueueNode));       //为新结点申请内存空间
    assert(s!=NULL);
    s->data = x;                            //数据域赋值
    s->next = NULL;                         //设置尾节点指向

    Q->tail->next = s;                      //连接当前队列尾部节点，进行入队操作
    Q->tail = s;                            //更新尾指针位置
}

void ShowQueue(LinkQueue *Q)                //输出队列---简单遍历队列
{
    QueueNode *p = Q->front->next;          //获取队列头结点
    printf("Front>");
    while(p!=NULL)                          //遍历队列、获取队列各节点数据域
    {
        printf("%d",p->data);
        p = p->next;
    }
    printf("<Tail");
    printf("\n");
}

void DeQueue(LinkQueue *Q)                  //出队操作--头结点出队
{
    if(Q->front == Q->tail)                 //判空
        return;
    QueueNode *p = Q->front->next;          //获取队列头结点
    Q->front->next = p->next;               //更新队列头结点
    free(p);                                //释放队列头结点
    if(p == Q->tail)                        //判断释放节点是否为当前队列的尾节点、更新队尾指针
        Q->tail = Q->front;
    /*
    while(p!=NULL)
    {
        Q->front->next = p->next;
        free(p);
        p = Q->front->next;
    }*/
}

EType GetHead(LinkQueue *Q)              //获取队列首元素
{
    if(Q->front == Q->tail)
        return NULL;
    QueueNode *q = Q->front->next;
    EType p = q->data;
    return p;
}

int Length(LinkQueue *Q)                    //获取当前队列长度
{
    int len = 0;
    QueueNode *p = Q->front->next;
    while(p!=NULL)                          //简单遍历队列
    {
        len++;                              //计数
        p = p->next;
    }
    return len;
}

void ClearQueue(LinkQueue *Q)               //逐个清除队列节点
{
    if(Q->front == Q->tail)
        return;
    QueueNode *p = Q->front->next;
    while(p!=NULL)
    {
        Q->front->next = p->next;
        free(p);                            //释放该节点
        p = Q->front->next;
    }
}

void DestroyQueue(LinkQueue *Q)             //摧毁队列
{
    ClearQueue(Q);
    free(Q->front);
    Q->front = Q->tail = NULL;
}

bool QueueIsEmpty(LinkQueue *Q)
{
    return (Q->front==Q->tail);
}


int main()
{
    LinkQueue Q;
    InitQueue(&Q);
    for(int i=1;i<10;i++)
    {
        EnQueue(&Q,i);
    }
    ShowQueue(&Q);
    DeQueue(&Q);
    ShowQueue(&Q);
    printf("Length = %d",Length(&Q));
    return 0;
}

 

2、顺序结构下实现队列的基本操作

#include<stdio.h>
#include<assert.h>
#include<malloc.h>

#define ElemType int
#define MAXSIZE 9

typedef struct Queue                //队列节点结构体
{
    ElemType *base;                 //节点数据域
    int front;                      //头指针
    int rear;                       //尾指针
}Queue;

void InitQueue(Queue *Q)            //初始化
{
    Q->base = (ElemType*)malloc(sizeof(ElemType)*MAXSIZE);
    assert(Q->base != NULL);
    Q->front = Q->rear = 0;
}

void EnQueue(Queue *Q,ElemType x)       //进队操作
{
    if(Q->rear >= MAXSIZE)
        return;
    Q->base[Q->rear] = x;
    Q->rear++;
}

void DeQueue(Queue *Q)                  //出队操作
{
    if(Q->front == Q->rear)
        return 0;
    ElemType p = Q->base[Q->front];
    Q->front++;
}

ElemType GetHead(Queue *Q)              //获取队头元素
{
    if(Q->front == Q->rear)
        return 0;
    ElemType p = Q->base[Q->front];
    //Q->front++;
    return p;
}

int Length(Queue *Q)                    //获取队列长度
{
    int len = Q->rear - Q->front;
    return len;
}

void ClearQueue(Queue *Q)               //清除队列
{
    Q->front = Q->rear = 0;
}

void DestroyQueue(Queue *Q)             //摧毁队列
{
    free(Q->base);
    Q->base = NULL;
}

void ShowQueue(Queue *Q)                //输出队列
{
    for(int i=Q->front;i<Q->rear;++i)
    {
        printf("%d ",Q->base[i]);
    }
    printf("\n");
}
int main()
{
    Queue Q;
    InitQueue(&Q);
    for(int i=1;i<4;i++)
    {
        EnQueue(&Q,i);
    }
    ShowQueue(&Q);
    DeQueue(&Q);
    ShowQueue(&Q);
    //printf("Length = %d",Length(&Q));
    return 0;
}