顺序栈C语言

顺序栈

SqStack.h文件

#ifndef SQSTACK_H
#define SQSTACK_H

typedef unsigned  int SElemType;    //SElemType类型根据实际情况而定

typedef struct
{
    SElemType* base;                //栈底
    unsigned int Length;            //栈顶
    unsigned int MaxSize;           //存储空间最大值
}SqStack;

/*空栈*/
void SqStack_Init(SqStack* S, unsigned int size);
/*入栈*/
void SqStack_Push(SqStack* S, SElemType e);
/*遍历栈*/
void SqStack_Traverse(SqStack S);
/*获取栈顶元素*/
SElemType SqStack_GetTop(SqStack S);
/*出栈*/
SElemType SqStack_Pop(SqStack* S);
/*清空栈*/
void SqStack_Clear(SqStack* S);
/*销毁栈*/
void SqStack_Destroy(SqStack* S);
/*测试*/
void SqStack_Test(void);

#endif // SQSTACK_H

SqStack.c文件

#include "SqStack.h"

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

static const unsigned int INCREMENT = 5;       //存储空间增量

/*空栈*/
void SqStack_Init(SqStack* S,unsigned int size)
{
    S->Length = 0;
    S->MaxSize = size;
    S->base = calloc(sizeof(SElemType), S->MaxSize);
}
/*入栈，尾进*/
void SqStack_Push(SqStack* S, SElemType e)
{
    assert(S->base != NULL);    //顺序栈存在

    S->base[S->Length] = e;
    S->Length += 1;

    if (S->Length == S->MaxSize)
    {
        S->MaxSize += INCREMENT;
        SElemType * temp = realloc(S->base, sizeof(SElemType) * S->MaxSize);
        if (temp != NULL)            //防止重新分配内存失败后，原地址丢失
        {
            S->base = temp;
        }
    }
}
/*遍历栈*/
void SqStack_Traverse(SqStack S)
{
    assert(S.Length != 0);   //断言，顺序栈不空

    for (unsigned int i = 0; i < S.Length; i++)
    {
        printf("%d ", S.base[i]);
    }
    printf("\n");
}
/*获取栈顶元素*/
SElemType SqStack_GetTop(SqStack S)
{
    assert(S.Length != 0);   //断言，顺序栈不空

    return S.base[S.Length - 1];
}
/*出栈，尾出*/
SElemType SqStack_Pop(SqStack* S)
{
     assert(S->Length != 0);   //断言，顺序栈不空

    SElemType e;
    S->Length -= 1;
    e = S->base[S->Length];
    S->base[S->Length] = 0;
    return e;
}
/*清空栈*/
void SqStack_Clear(SqStack* S)
{
    assert(S->Length != 0);   //断言，顺序栈不空

    for (unsigned int i = 0; i < S->Length; i++)
    {
        S->base[i] = 0;
    }
    S->Length = 0;
}
/*销毁栈*/
void SqStack_Destroy(SqStack* S)
{
    assert(S->base != NULL);    //顺序栈存在

    free(S->base);
    S->base = NULL;
    S->Length = 0;
    S->MaxSize = 0;
}

/*测试*/
void SqStack_Test(void)
{
    SqStack S;
    SqStack_Init(&S, 4);
    SqStack_Push(&S, 1);
    SqStack_Push(&S, 2);
    SqStack_Push(&S, 3);
    SqStack_Push(&S, 4);
    SqStack_Push(&S, 5);
    SqStack_Traverse(S);
    SqStack_Pop(&S);
    SqStack_Traverse(S);
    printf("%d\n", S.base[S.Length - 1]);
    SqStack_Clear(&S);
    printf("%d\n", S.base[2]);
    SqStack_Destroy(&S);
    printf("%p\n", S.base);
}

测试：main.c文件

#include  <stdio.h>
#include "SqStack.h"

int main()
{
	SqStack_Test();
	return 0;
}

测试结果