【数据结构】顺序栈的实现

概念 

  栈实际上是一种特殊的线性表, 只是对插入删除进行了限制, 只能在一端进行插入删除, 插入删除的一端叫栈顶, 另一端叫栈底

  栈中的元素遵循先进后出的原则

  压栈 : 栈的插入操作, 也叫入栈, 入数据在栈顶

  出栈 : 栈的删除操作叫做出栈, 出数据也在栈顶

实现

  栈的实现一般可以使用顺序表或者链表实现, 相对而言顺序表的结构实现更优一些, 因为顺序表尾插尾删都是O(1)的操作,

而且增容不是每次都要增容, 不容易造成内存碎片, 所以在这里我们使用顺序表来实现 

Stack.h

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

typedef int Datatype;
typedef struct Stack
{
	Datatype* _s;
	size_t _top;
	size_t _capacity;
}Stack;

//初始化
void StackInit(Stack* s);
//销毁
void StackDestory(Stack* s);
//入栈
void StackPush(Stack* s, Datatype x);
//出栈
void StackPop(Stack* s);
//返回栈顶元素
Datatype StackTop(Stack* s);
//判空
size_t StackEmpty(Stack* s);
//返回栈的大小
size_t StackSize(Stack* s);
//打印栈
void StackPrint(Stack* s);

Realize.c

#include "Stack.h"

void StackInit(Stack* s)
{
	assert(s);
	//空栈
	s->_s = NULL;
	s->_top = 0;
	s->_capacity = 0;
}

void StackDestory(Stack* s)
{
	assert(s);
	if (s->_s)
	{
		s->_s = NULL;
		s->_top = s->_capacity = 0;
		free(s->_s);
	}
}

void StackPush(Stack* s, Datatype x)
{
	assert(s);
	///入栈:顺序表尾插
	//检查容量
	if (s->_top == s->_capacity)
	{
		size_t newcapacity = s->_capacity == 0 ? 10 : 2 * s->_capacity;
		//realloc不需要自行拷贝原有空间内容
		s->_s = (Datatype*)realloc(s->_s, newcapacity * sizeof(Datatype));
		s->_capacity = newcapacity;
	}
	s->_s[s->_top++] = x;
}

void StackPop(Stack* s)
{
	assert(s);
	//尾删
	if (s->_top > 0)
		--s->_top;
}

Datatype StackTop(Stack* s)
{
	assert(s);
	return s->_s[s->_top - 1];
}

size_t StackEmpty(Stack* s)
{
	assert(s);
	return s->_top == 0 ? 1 : 0;
}

size_t StackSize(Stack* s)
{
	return s->_top;
}

void StackPrint(Stack* s)
{
	assert(s);
	while (!StackEmpty(s))
	{
		printf("%d ", StackTop(s));
		StackPop(s);
	}
	printf("\n");
}

Test.c

#include "Stack.h"

void TestStack()
{
	Stack s;
	StackInit(&s);
	StackPush(&s, 1);
	StackPop(&s);
	StackPush(&s, 3);
	StackPush(&s, 4);
	StackPop(&s);
	StackPush(&s, 5);
	StackPrint(&s);
	StackDestory(&s);
}

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

运行结果