栈与队列的实现

栈

栈的声明

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

typedef int DataType;

typedef struct Stack
{
    DataType *st;
    size_t size;
    size_t capacity;
}Stack, *pStack;

void StackInit(pStack s,DataType x);
void StackPush(pStack s, DataType x);
void StackPop(pStack s);
DataType StackTop(pStack s);
size_t StackSize(pStack s);
DataType StackEmpty(pStack s);
void StackDestory(pStack s);

栈的实现

#include "Stack.h"

void StackInit(pStack s, DataType capacity)//初始化
{
    assert(s && capacity >= 0);
    s->st = (DataType *)malloc(sizeof(DataType)*capacity);
    assert(s->st);
    s->capacity = capacity;
    s->size = 0;
}
void StackPush(pStack s, DataType x)//压栈
{
    assert(s);
    if (s->size == s->capacity)//增容
    {
        s->capacity *= 2;
        s->st = (DataType *)realloc(s->st, sizeof(DataType)*s->capacity);
    }
    s->st[s->size++] = x;
}
void StackPop(pStack s)//出栈
{
    assert(s && s->size);
    --s->size;
}
DataType StackTop(pStack s)//返回栈顶数据
{
    assert(s && s->size);
    return s->st[s->size - 1];
}
size_t StackSize(pStack s)//返回栈元素个数
{
    assert(s);
    return s->size;
}
//空返回0.否则返回非0
DataType StackEmpty(pStack s)//判断是否空栈
{
    assert(s);
    return s->size;
}
void StackDestory(pStack s)//销毁
{
    free(s->st);
    s->st = NULL;
    s->capacity = s->size = 0;
}

测试代码

void TestStack()
{
    Stack s;
    StackInit(&s, 3);
    StackPush(&s, 1);
    StackPush(&s, 2);
    StackPush(&s, 3);
    StackPush(&s, 4);
    StackPush(&s, 5);
    StackPush(&s, 6);
    while (StackEmpty(&s) != 0)
    {
        printf("%d ", StackTop(&s));
        StackPop(&s);
    }
    printf("\n");
}

队列

队列的声明

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

typedef int DataType;
//节点
typedef struct QueueNode
{
    DataType data;
    struct QueueNode *next;
}QueueNode, *pQueueNode;
//队列
typedef struct Queue
{
    pQueueNode head;
    pQueueNode tail;
}Queue, *pQueue;

void QueueInit(pQueue q);
void QueuePush(pQueue q,DataType x);
void QueuePop(pQueue q);
DataType QueueFront(pQueue q);
DataType QueueBack(pQueue q);
size_t QueueSize(pQueue q);
DataType QueueEmpty(pQueue q);
void QueueDestory(pQueue q);

队列的定义

#include "Queue.h"

pQueueNode BuyQueueNode(DataType x)
{
    pQueueNode node = (pQueueNode)malloc(sizeof(QueueNode));
    node->data = x;
    node->next = NULL;
    return node;
}
void QueueInit(pQueue q)
{
    assert(q);
    q->head = NULL;
    q->tail = NULL;
}
void QueuePush(pQueue q, DataType x)//队尾入栈
{
    assert(q);
    if (q->tail == NULL)//空队列
        q->head = q->tail = BuyQueueNode(x);
    else
    {
        q->tail->next = BuyQueueNode(x);
        q->tail = q->tail->next;
    }
}
void QueuePop(pQueue q)//对头出栈
{
    assert(q);
    if (q->head == NULL)//空队列
        q->head = q->tail = NULL;
    else
    {
        pQueueNode node = q->head->next;
        free(q->head);
        q->head = node;
        if (q->head == NULL){
            q->tail = NULL;
        }
    }
}
DataType QueueFront(pQueue q)//返回队头的值
{
    assert(q);
    assert(q->head);
    return q->head->data;
}
DataType QueueBack(pQueue q)//返回对尾的值
{
    assert(q);
    assert(q->head);
    return q->tail->data;
}
size_t QueueSize(pQueue q)
{
    assert(q);
    pQueueNode node = q->head;
    size_t count = 0;
    while (node != NULL)
    {
        count++;
        node = node->next;
    }
    return count;
}
DataType QueueEmpty(pQueue q)
{
    return QueueSize(q) == 0 ? 1 : 0;
}
void QueueDestory(pQueue q)
{
    assert(q);
    pQueueNode node = q->head;
    while (node)
    {
        pQueueNode cur = node->next;
        free(node);
        node = cur;
    }
    q->head = q->tail = NULL;
}

测试代码

void TestQueue()
{
    Queue q;
    QueueInit(&q);
    QueuePush(&q, 1);
    QueuePush(&q, 2);
    QueuePush(&q, 3);
    QueuePush(&q, 4);
    printf("%d\n",QueueSize(&q));
    while (QueueEmpty(&q)!=1)
    {
        printf("%d ", QueueFront(&q));
        QueuePop(&q);
    }
    printf("\n");
}