栈 和 队列

栈

定义

栈，是限定仅在表尾进行插入或删除操作的线性表。表为段有其特殊含义，称为栈顶，表头端称为栈底。不含元素的空表称为空栈。

栈的存储结构

typedef int STDatatype;
typedef struct StackNode
{
        STDatatype* a;
        int top;
        int length;
}Stack;

栈的基本操作

//初始化
void  StackInit(Stack* pd);
//入栈
void StackPush(Stack* pd,STDatatype x);
//判空
bool StackEmpty(Stack* pd);
//出栈
void StackPop(Stack* pd);
//栈顶元素
STDatatype StackTop(Stack* pd);
//长度
int StackSize(Stack* pd);
//销毁
void StackDestroy(Stack* pd);

初始化

void  StackInit(Stack* pd)
{
    assert(pd);
    pd->a = NULL;
    pd->top = 0;
    pd->length = 0;
}

扩展空间

void StackSpace(Stack* pd)
{
        int length = pd->length == 0 ? 4 : pd->length * 2;
        STDatatype* tmp = (STDatatype*)realloc(pd->a,sizeof(STDatatype)*length);
        if (tmp == NULL)
        {
        perror("realloc fali");
        return;
        }
        pd->a = tmp;
        pd->length = length;
}

入栈

void StackPush(Stack* pd, STDatatype x)
{
        assert(pd);
        if (pd->top == pd->length)
        {
        StackSpace(pd);
            }
        pd->a[pd->top] = x;
        pd->top++;
}

判空

bool StackEmpty(Stack* pd)
{
        assert(pd);
        return pd->top == 0;
}

出栈

void StackPop(Stack* pd)
{
        assert(pd);
        assert(!StackEmpty(pd));
        pd->top--;
}

栈顶元素

STDatatype StackTop(Stack* pd)
{
        assert(pd);
        assert(!StackEmpty(pd));
        return pd->a[pd->top-1];
}

长度

int StackSize(Stack* pd)
{
        assert(pd);
        return pd->top;
}

销毁

void StackDestroy(Stack* pd)
{
        assert(pd);
        free(pd->a);
        pd->a = NULL;
        pd->top = 0;
        pd->length = 0;
}

队列

定义

队列是一种先进先出的线性表。它只允许在表的一端进行插入，而在另一端删除元素。

队列存储结构

typedef int QTDatatype;
typedef struct QueueNode
{
        struct QueueNode* next;
    QTDatatype data;
}QNode;
typedef struct Queue
{
    QNode* phead;//队列头结点
    QNode* tail;
//队列尾结点
        int size;
}Queue;

队列基础操作

//初始化
void QueueInit(Queue* qp);
//入队
void QueuePush(Queue* qp,QTDatatype x);
//判空
bool QueueEmpty(Queue* qp);
//出队
void QueuePop(Queue* qp);
//队头元素
QTDatatype QueueFront(Queue* qp);
//队尾元素
QTDatatype QueueBack(Queue* qp);
//队的长度
int QueueSize(Queue* qp);
//销毁
void QueueDestroy(Queue* qp);

初始化

void QueueInit(Queue* qp)
{
    assert(qp);
    qp->phead = NULL;
    qp->tail = NULL;
    qp->size = 0;
}

创建结点

QNode* BuyQueueNode(QTDatatype x)
{
        QNode* newnode = (QNode*)malloc(sizeof(QNode));
        if (newnode == NULL)
        {
        perror("malloc fail");
        return NULL;
        }
        newnode->data = x;
        newnode->next = NULL;
        return newnode;
}

入队

void QueuePush(Queue* qp, QTDatatype x)
{
        assert(qp);
        QNode* newnode = BuyQueueNode(x);
        if (qp->tail == NULL)//一个结点时
        {
        assert(qp->phead == NULL);
        qp->phead = qp->tail = newnode;
        }
        else
        {
        qp->tail->next = newnode;
        qp->tail = newnode;
        }
        qp->size++;
}

判空

bool QueueEmpty(Queue* qp)
{
        assert(qp);
        return qp->phead == NULL && qp->tail == NULL;
}

出队

void QueuePop(Queue* qp)
{
        assert(qp);
        assert(!QueueEmpty(qp));
        if (qp->phead->next == NULL)//一个结点时
        {
        free(qp->phead);
        qp->phead = qp->tail = NULL;
        }
        else
        {
        QNode* tail = qp->phead->next;
        
        free(qp->phead);
        qp->phead = tail;
        }
        qp->size--;
}

队头元素

QTDatatype QueueFront(Queue* qp)
{
        assert(qp);
        assert(!QueueEmpty(qp));
        return qp->phead->data;
}

队尾元素

QTDatatype QueueBack(Queue* qp)
{
        assert(qp);
        assert(!QueueEmpty(qp));
        return qp->tail->data;
}

队的长度

int QueueSize(Queue* qp)
{
        assert(qp);
        return qp->size;
}

销毁

void QueueDestroy(Queue* qp)
{
        assert(qp);
        QNode* cur = qp->phead;
        while (cur != NULL)
        {
        QNode* tail = cur->next;
        free(cur);
        cur = tail;
        }
        qp->phead = qp->tail = NULL;
        qp->size = 0;
}

有不足和错误的话，麻烦各位大佬指点。