链式队列及相关操作

链式队列及相关操作

完整代码:https://github.com/zzaiyuyu/Queue

queue.h

#pragma once
#define DataType int
typedef struct Node {
    DataType data;
    struct Node * next;
}qNode;

//基于带头结点的单链表队列
typedef struct Queue {
    qNode * front;
    qNode * tail;
}LQueue;
//初始化队列
void InitQueue(LQueue *queue);
//队列入元素
void PushQueue(LQueue *queue, DataType data);
//队列出元素
void PopQueue(LQueue * queue);
//获取队头元素
DataType QueueFront(LQueue* queue);
//获取队尾元素
DataType QueueTail(LQueue* queue);
//获取队列长度
int QueueSize(LQueue* queue);
//判空
int QueueEmpyt(LQueue* queue);
//销毁队列
void DestoryQueue(LQueue** queue);

queue.c

#include "queue.h"
#include <assert.h>
#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
qNode * BuyNode(DataType data)
{
    qNode * new = (qNode*)malloc(sizeof(qNode));
    if (NULL == new) {
        printf("分配失败");
        return NULL;
    }
    new->data = data;
    new->next = NULL;
    return new;
}
void InitQueue(LQueue *queue)
{
    assert(queue);
    //创建头结点
    qNode * head= BuyNode(0);
    queue->front = head;
    queue->tail = head;
}
void PushQueue(LQueue *queue, DataType data)
{
    qNode *new = BuyNode(data);
    queue->tail->next = new;
    queue->tail = new;
}
void PopQueue(LQueue * queue)
{
    qNode *pDel = queue->front->next;
    //不是空队列
    if (pDel) {
        //除头结点只有一个结点
        if (NULL == pDel->next) {
            queue->tail = queue->front;
        }
        queue->front->next = pDel->next;
        free(pDel);
    }
}

DataType QueueFront(LQueue* queue)
{
    //有元素
    if (queue->front->next) {
        return queue->front->next->data;
    }
    exit(EXIT_FAILURE);
}
//获取队尾元素
DataType QueueTail(LQueue* queue)
{
    if (queue->tail == queue->front) {
        exit(EXIT_FAILURE);
    }
    return queue->tail->data;
}
int QueueSize(LQueue* queue)
{
    int count = 0;
    qNode * pcur = queue->front->next;
    while (pcur) {
        count++;
        pcur = pcur->next;
    }
    return count;
}
int QueueEmpyt(LQueue* queue)
{
    if (queue->front == queue->tail) {
        return 1;
    }
    return 0;
}
void DestoryQueue(LQueue** queue)
{
    if (*queue != NULL) {
        while ((*queue)->front) {
            PopQueue(*queue);
        }
        free(*queue);
        *queue = NULL;
    }

}

用两个队列实现一个栈

stackBy2Queue.h

#include "queue.h"

typedef struct TWOQ {
    LQueue queue1;
    LQueue queue2;
}StackByQ, *pStackByQ;

//初始化栈
void StackBy2QueueInit(pStackByQ s);

//入栈
void StackBy2QueuePush(pStackByQ s, DataType data);

//出栈
void StackBy2QueuePop(pStackByQ s);

//查看栈定元素
DataType StackBy2QueueTop(pStackByQ s);

//查看栈里的元素个数
int StackBy2QueueSize(pStackByQ s);

//判空 
int StackBy2QueueEmpty(pStackByQ s);

//测试
void TestStackBy2Queue();

stackBy2Queue.c

#include "stackBy2Queue.h"
#include "queue.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
//初始化栈
void StackBy2QueueInit(pStackByQ s)
{
    assert(s);
    InitQueue(&s->queue1);
    InitQueue(&s->queue2);
}

//入栈
void StackBy2QueuePush(pStackByQ s, DataType data)
{
    assert(s);
    //两个队列有一个为空，一个有数据，向有数据的队列放数据
    if (QueueEmpyt(&s->queue1) && QueueEmpyt(&s->queue2) || !QueueEmpyt(&s->queue1)) {
        PushQueue(&s->queue1, data);
    }
    else {
        PushQueue(&s->queue2, data);
    }
}

//出栈
void StackBy2QueuePop(pStackByQ s)
{
    assert(s);
    int size = 0;
    if (!QueueEmpyt(&s->queue1)) {
        size = QueueSize(&s->queue1) - 1;
        while (size--) {
            PushQueue(&s->queue2, QueueFront(&s->queue1));
            PopQueue(&s->queue1);
        }
        PopQueue(&s->queue1);
    }
    else if (!QueueEmpyt(&s->queue2)) {
        size = QueueSize(&s->queue1) - 1;
        while (size--) {
            PushQueue(&s->queue2, QueueFront(&s->queue1));
            PopQueue(&s->queue1);
        }
        PopQueue(&s->queue1);
    }
    else {
        printf("栈空\n");
    }
}

//判空 
int StackBy2QueueEmpty(pStackByQ s)
{
    assert(s);
    if (QueueEmpyt(&s->queue1) && QueueEmpyt(&s->queue2)) {
        return 1;
    }
    return 0;
}
//查看栈定元素
DataType StackBy2QueueTop(pStackByQ s)
{
    assert(s);
    if (StackBy2QueueEmpty(s)) {
        exit(EXIT_FAILURE);
    }
    if (!QueueEmpyt(&s->queue1)) {
        return QueueTail(&s->queue1);
    }
    else {
        return QueueTail(&s->queue2);
    }
}

//查看栈里的元素个数
int StackBy2QueueSize(pStackByQ s)
{
    assert(s);
    if (StackBy2QueueEmpty(s)) {
        return 0;
    }
    else {
        int size1 = QueueSize(&s->queue1);
        int size2 = QueueSize(&s->queue2);
        return  size1 ? size1 : size2;
    }
}

//测试
void TestStackBy2Queue()
{
    StackByQ stack;
    StackBy2QueueInit(&stack);
    StackBy2QueuePush(&stack, 1);

    StackBy2QueuePush(&stack, 2);
    StackBy2QueuePush(&stack, 3);
    int emp = StackBy2QueueEmpty(&stack);
    int size = StackBy2QueueSize(&stack);
    int top = StackBy2QueueTop(&stack);
    StackBy2QueuePop(&stack);
    StackBy2QueuePush(&stack, 4);
    int t = StackBy2QueueTop(&stack);


}