用顺序表实现栈（c语言）

概念篇

如果你提前学过顺序表的相关知识和代码，那么学习这篇文章你会轻松很多。感兴趣的朋友可以看下这篇文章线性表——顺序表（c语言）
对链表感兴趣的朋友可以看一下链表实现栈这篇文章。

栈是一种特殊的线性表，特殊于它先进后出的特征，而这个特征可以通过顺序表（数组）的方式实现。

示意图

代码篇

1.栈的声明

把一些属性封装起来表示栈。

typedef struct stack
{
	int*elements;//指向栈中元素的指针
	size_t size;//栈中元素的数量
	int capacity;//栈的容量
}stack; 

2.栈的创建

void stack_create(stack*stk)
{
	stk->elements=(int*)malloc(sizeof(int)*8);
	// 为栈分配足够的内存以存储8个整数 
	stk->size=0;
	stk->capacity=8;
	// 容量初始化为8，表示栈最多可以存储8个元素  
}

3.栈的销毁

释放分配的内存空间

void stack_destory(stack*stk)
{
	free(stk->elements);
	//释放分配内存
    stk->elements=NULL;
    //指针为空
    stk->size=0;
    stk->capacity=0;
}

4.栈的扩容

在这里我把容量扩大了原来的两倍

void stack_realize(stack*stk)
{
	int *newelements=(int*)realloc(stk->elements,sizeof(int)*stk->capacity*2);
	//尝试将elements的存储空间扩大到原来的两倍。 
	stk->elements=newelements;
	stk->capacity*=2;
	//更新stack的capacity成员
}

5.入栈

1.判断栈是否满了，满了则扩容。
2.没满则在末尾插入元素。

void stack_push(stack*stk,int value)
{
	if(stk->size==stk->capacity)
		stack_realize(stk);
		//如果栈中的元素个数等于栈的最大容量则扩容
	stk->elements[stk->size++]=value;
	/*末尾插入元素，并且元素个素自增
	也可以写成：
	stk->elements[stk->size]=value;
	stk->size++;
	*/
}

6.出栈

int stack_pop(stack*stk)
{
	if(stk->size==0)
    {
    	//如果当前元素为0，不能出栈
        printf("stack underflow");
        exit(1);
    }
    return stk->elements[--stk->size];
    //返回出栈的元素并且更新元素数量
}

7.返回栈顶元素

如果栈不为空直接返回末尾元素

int stack_top(stack*stk)
{
	if(stk->size==0)
        printf("stack is empty!");
	return stk->elements[stk->size-1];
	//返回末尾元素
}

8.栈的元素个数

直接返回stack的size成员

int stack_size(stack*stk)
{
    return stk->size;
}

9.完整代码

#include<stdio.h>
#include<stdlib.h>
typedef struct stack
{
	int*elements;//指向栈中元素的指针
	size_t size;//栈中元素的数量
	int capacity;//栈的容量
}stack;
void stack_create(stack*stk)
{
	stk->elements=(int*)malloc(sizeof(int)*8);
	//为栈分配足够的内存以存储8个整数 
	stk->size=0;
	stk->capacity=8;
	// 容量初始化为8，表示栈最多可以存储8个元素  
}
void stack_destory(stack*stk)
{
	free(stk->elements);
	//释放分配内存
    stk->elements=NULL;
    //指针为空
    stk->size=0;
    stk->capacity=0;
}
void stack_realize(stack*stk)
{
	int *newelements=(int*)realloc(stk->elements,sizeof(int)*stk->capacity*2);
	//尝试将elements的存储空间扩大到原来的两倍。 
	stk->elements=newelements;
	stk->capacity*=2;
	//更新stack的capacity成员
}
void stack_push(stack*stk,int value)
{
	if(stk->size==stk->capacity)
		stack_realize(stk);
		//如果栈中的元素个数等于栈的最大容量则扩容
	stk->elements[stk->size++]=value;
	/*末尾插入元素，并且元素个素自增
	也可以写成：
	stk->element[size]=value;
	stk->size++;
	*/
}
int stack_pop(stack*stk)
{
	if(stk->size==0)
    {
    	//如果当前元素为0，不能出栈
        printf("stack underflow");
        exit(1);
    }
    return stk->elements[--stk->size];
    //返回出栈的元素并且更新元素数量
}
int stack_top(stack*stk)
{
	if(stk->size==0)
        printf("stack is empty!");
	return stk->elements[stk->size-1];
	//返回末尾元素
}
int stack_size(stack*stk)
{
    return stk->size;
}
int main()
{
    stack stk;
    stack_create(&stk);
    stack_push(&stk,10);
    stack_push(&stk,20);
    stack_push(&stk,30);
    //10 20 30
    printf("stacktop is:%d\n",stack_top(&stk));
    //30
    printf("stackpop is:%d\n",stack_pop(&stk));
    //30
    printf("stacksize is:%d\n",stack_size(&stk));
    //2
    stack_destory(&stk);
    return 0;
}
/*应该打印
30
30
2
*/

运行效果

在这篇文章中我用了顺序表来写栈，在下一篇文章中我会用链表来写栈
希望这篇文章能让你有所启发，也希望其他朋友能对我的文章进行补充和指正，感激不尽