C语言实现顺序栈

栈：是一种特殊的线性表，我们只能对栈 的固定的一端进行插入和删除元素操作。这固定的一端被称之为栈顶，另外一端就叫做栈底。如果一个栈中没有任何元素就将其称为空栈。
特性：先进后出（后进先出）

seqstack.h文件

#pragma once

#include<stddef.h>

typedef char seqStackType;

typedef struct seqStack
{
    seqStackType *data;
    size_t size;
    //表示data段内存中能容纳的元素个数
    size_t capacity;
}seqStack;

seqStack stack;

//初始化函数
void seqStackInit(seqStack *stack);
//销毁函数
void seqStackDestroy(seqStack *stack);
//入栈函数
void seqStackPush(seqStack *stack,seqStackType value);
//出栈函数
void seqStackPop(seqStack *stack);
//取栈顶元素函数
int seqStackGetTop(seqStack *stack,seqStackType *value);

seqstack.c文件

#include<stdio.h>
#include<stdlib.h>
#include"seqstack.h"

#define Test_Header printf("\n==========%s==========\n",__FUNCTION__);

//初始化函数
void seqStackInit(seqStack *stack)
{
    if(stack == NULL)
    {
        //非法输入
        return;
    }
    stack->size = 0;
    stack->capacity = 1000;
    stack->data = (seqStackType*)malloc(stack->capacity * sizeof(seqStackType));
}
//销毁函数
void seqStackDestroy(seqStack *stack)
{
    if(stack == NULL)
    {
        //非法输入
        return;
    }
    free(stack->data);
    stack->data == NULL;
    stack->size = 0;
    stack->capacity = 0;
}
//栈的扩容函数
void seqStackReSize(seqStack *stack)
{
    if(stack == NULL)
    {
        //非法输入
        return;
    }
    //栈的实际存储的元素个数小于规定的能容纳的最大数量
    if(stack->size < stack->capacity)
    {
        //无需扩容，直接返回
        return;
    }
    //扩容规则由自己决定
    stack->capacity = stack->capacity * 2 + 1;
    seqStackType *new_ptr = (seqStackType*)malloc(stack->capacity * sizeof(seqStackType));
    //将原来栈的元素一一复制到新扩容的栈中
    size_t i = 0;
    for(;i < stack->size;i++)
    {
        new_ptr[i] = stack->data[i];
    }
    //释放掉旧栈
    free(stack->data);
    //将栈的数据域指向新栈的数据域
    stack->data = new_ptr;
    return;
}
//入栈函数
void seqStackPush(seqStack *stack,seqStackType value)
{
    if(stack == NULL)
    {
        //非法输入
        return;
    }
    //每次入栈前都需要判断栈是否含有空间供我们插入元素
    if(stack->size >= stack->capacity)
    {
        //如果栈空间满了
        //则需要扩容
        seqStackReSize(stack);
    }
    //将栈的最后一个元素设置为需要入栈的元素值
    //将有效元素个数+1
    stack->data[stack->size++] = value;
}
//出栈函数
void seqStackPop(seqStack *stack)
{
    if(stack == NULL)
    {
        //非法输入
        return;
    }
    if(stack->size == 0)
    {
        //空栈无法再进行出栈操作
        return;
    }
    //出栈只需要将栈的有效元素个数减1
    --stack->size;
}
//取栈顶元素函数
//失败返回0，成功返回1
int seqStackGetTop(seqStack *stack,seqStackType *value)
{
    if(stack == NULL)
    {
        //非法输入
        return 0;
    }
    if(stack->size == 0)
    {
        //空栈
        return 0;
    }
    //value为一个输出型参数
    //栈顶元素为最后一个入栈的元素
    *value = stack->data[stack->size-1];
    return 1;
}
//打印函数
void Print(seqStack *stack,const char *msg)
{
    printf("[%s]\n",msg);
    if(stack == NULL)
    {
        //非法输入
        return;
    }
    if(stack->size == 0)
    {
        //空栈
        printf("\n");
        return;
    }
    size_t i = 0;
    for(;i < stack->size;i++)
    {
        printf("%c ",stack->data[i]);
    }
    printf("\n\n");
}

void TestStack()
{
    Test_Header;
    //测试初始化
    seqStackInit(&stack);
    printf("expected:size = 0,capacity = 1000\nactual:size = %lu,capacity = %lu\n\n",stack.size,stack.capacity);
    //测试入栈操作
    seqStackPush(&stack,'a');
    seqStackPush(&stack,'b');
    seqStackPush(&stack,'c');
    seqStackPush(&stack,'d');
    Print(&stack,"入栈4个元素");
    seqStackPop(&stack);
    seqStackPop(&stack);
    //测试出栈操作
    Print(&stack,"出栈2个元素");
    seqStackPop(&stack);
    seqStackPop(&stack);
    Print(&stack,"再出栈2个元素");
    seqStackPop(&stack);
    Print(&stack,"尝试对空栈进行出栈操作");
    seqStackPush(&stack,'a');
    seqStackPush(&stack,'b');
    //测试取栈顶元素函数
    Print(&stack,"入栈2个元素");
    seqStackType value;
    int ret = seqStackGetTop(&stack,&value);
    printf("\nexpected:1 b\nactual:%d %c\n\n",ret,value);
    //测试销毁函数
    seqStackDestroy(&stack);
    printf("expected:size = 0,capacity = 0\nactual:size = %lu,capacity = %lu\n\n",stack->size,stack->capacity);
}
//主函数调用测试函数
int main()
{
    TestStack();
    return 0;
}

测试结果如下图：