栈的定义：

栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。
栈中的数据元素遵守后进先出的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈，出数据也在栈顶。

而栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。

下面是定长的静态栈的结构，实际中一般不实用，所以我们主要实现下面的支持动态增长的栈

//静态的栈
typedef int STDataType;
typedef struct Stack
{
STDataType _a[100];
int _top; // 栈顶
};

// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
STDataType* _a;
int _top; // 栈顶
int _capacity; // 容量
};

Stack.h

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



// 动态增长的栈
typedef int STDataType;

typedef struct Stack
{
	STDataType* _a;
	int _top; // 栈顶
	int _capacity; // 容量
}Stack;
void StackInit(Stack* ps);
void StackDestory(Stack* ps);
void StackPush(Stack* ps, STDataType x);
void StackPop(Stack* ps);
STDataType StackTop(Stack* ps);
int StackEmpty(Stack* ps);
int StackSize(Stack* ps);
void TestStack();
void CheckCapacity(Stack* ps);
void PrintStack(Stack* ps);


``````java
Stack.c
#define _CRT_SECURE_NO_WARNINGS 1

#include "stack.h"
void StackInit(Stack* ps)
{
	assert(ps);
   ps->_a=(STDataType*)malloc(sizeof(STDataType)*3);
   if(NULL==ps->_a)
   {
	   perror(ps->_a);
	   return;
   }
   ps->_capacity=3;
   ps->_top=0;
}
void StackDestory(Stack* ps)
{
   assert(ps);
   ps->_capacity=0;
   ps->_top=0;
   free(ps->_a);
   ps->_a=NULL;
   printf("销毁栈成功！\n");


}
void CheckCapacity(Stack* ps)
{

	STDataType*ret=NULL;
	int newcapa=0;
	assert(ps);
	newcapa=2*(ps->_capacity);
	
		//增容
		ret=(STDataType*)malloc(sizeof(STDataType)*newcapa);
		if(ret==NULL)
		{
			assert(0);
			return;

		}
		else
		{
			memcpy(ret,ps->_a,sizeof(STDataType)*ps->_top);
			
			free(ps->_a);
			ps->_a=ret;
			ps->_capacity=newcapa;
		}
		}
void StackPush(Stack* ps, STDataType x)//栈顶插入一个元素
{
	assert(ps);
	if(ps->_top==ps->_capacity)
	{
          CheckCapacity(ps);
	}
	
	ps->_a[ps->_top]=x;
	ps->_top+=1;

}
void StackPop(Stack* ps)//栈顶删除一个元素
{
	assert(ps);
	ps->_top--;
}
STDataType StackTop(Stack* ps)//取出栈顶的元素
{
   assert(ps);
   return ps->_a[ps->_top-1];
}
int StackEmpty(Stack* ps)//清空栈
{
	assert(ps);
	ps->_top=0;
	printf("清空栈成功！\n");
	return ps->_top;

}
int StackSize(Stack* ps)//求栈里面的元素个数
{
   assert(ps);
   return ps->_top;
}
void PrintStack(Stack* ps)
{
	int i=0;
	assert(ps);
	if(ps->_top==0)
	{
		return;
	}
	else
	{
		for(i=0;i<ps->_top;i++)
		{
			printf("%d ",ps->_a[i]);
		}
		printf("\n");
	}
}

void TestStack()
{
	Stack p;
	StackInit(&p);//初始化
	
	StackPush(&p,1);//入栈
	StackPush(&p,2);
	StackPush(&p,3);
	StackPush(&p,4);
	StackPush(&p,5);
    PrintStack(&p);//打印当前的栈
	StackPop(&p);//出栈
	PrintStack(&p);//打印

   printf("栈顶的元素是：%d\n",StackTop(&p));
   printf("栈里面一共有%d个元素\n",StackSize(&p));
   StackEmpty(&p);//清空栈
   StackDestory(&p);//销毁栈
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1


#include "stack.h"

int main()
{
	TestStack();
	system("pause");
	return 0;
}

运行结果如下：