栈与队列的基本操作

1. 利用顺序表实现栈

Stack.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

#define MAX_SIZE (100)
typedef int SDataType;
typedef struct Stack
{
    SDataType array[MAX_SIZE];
    int top;//与数据顺序表size一样，1：有效的数据个数 2：top下标表示可用位置
}Stack;
//初始化
void StackInit(Stack *pS)
{
    assert(pS!=NULL);
    pS->top = 0;
}
//入栈
void StackPush(Stack *pS,SDataType data)
{
    assert(pS);
    assert(pS->top < MAX_SIZE);
    pS->array[pS->top++] = data;
}
//出栈
void StackPop(Stack *pS)
{
    assert(pS != NULL);
    assert(pS->top>0);
    pS->top--;
}
//返回栈顶元素
SDataType StackTop(Stack *pS)
{
    assert(pS != NULL);
    assert(pS->top>0);
    return pS->array[pS->top - 1];
}
//判空
int IsEmpty(Stack *pS)
{
    return pS->top == 0 ? 1 : 0;//空返回1，不空返回0
}
//返回栈的大小
int StackSize(Stack *pS)
{
    return pS->top;
}

1. 利用单链表实现队列
   Queue.h

#pragma once

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

typedef int QDataType;
typedef struct QNode
{
    QDataType data;
    struct QNode *pNext;
}QNode;
typedef struct Queue
{
    QNode *pFront;
    QNode *pRear;
    int size;
}Queue;

//初始化
void QueueInit(Queue *pQ)
{
    assert(pQ != NULL);
    pQ->pFront = pQ->pRear = NULL;
    pQ->size = 0;
}

//入队列
void QueuePush(Queue *pQ, QDataType data)
{
    pQ->size++;
    //通常情况
    QNode *pNewNode = (QNode *)malloc(sizeof(QNode));
    pNewNode->data = data;
    pNewNode->pNext = NULL;
    if (pQ->pRear == NULL)
    {
        pQ->pRear = pQ->pFront = pNewNode;
        return;
    }
    pQ->pRear->pNext = pNewNode;
    pQ->pRear = pNewNode;
}

// 出队列 
void QueuePop(Queue *pQ)
{
    assert(pQ);
    assert(pQ->size > 0);
    pQ->size--;
    QNode *pOldFront = pQ->pFront;
    pQ->pFront = pQ->pFront->pNext;
    free(pOldFront);
    if (pQ->pFront == NULL)
    {
        pQ->pRear = NULL;
    }

}

// 返回队首元素
QDataType QueueTop(Queue *pQ)
{
    return pQ->pFront->data;
}

// 判断是否为空 
// 1 空 
// 0 不空
int isEmpty(Queue *pQ)
{
    return pQ->size == 0 ? 1 : 0;
}

// 返回数据个数 
int QueueSize(Queue *pQ)
{
    return pQ->size;
}