顺序栈和链式栈的基本操作

栈作为一种 数据结构，是一种只能在一端进行插入和删除操作的特殊 线性表。它按照 先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底 指针。

栈是允许在同一端进行插入和删除操作的特殊 线性表。允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入一般称为 进栈（PUSH），删除则称为退栈（POP）。栈也称为后进先出表。

顺序栈的实现

stack.h

#pragma once
#define _CRT_SECURE_NO_WARN
typedef int DataType;
typedef struct Stack1
{
	DataType*top;
	size_t size;
	size_t capacity;
}Stack;

void IntiStack(Stack*ps, size_t capacity);//初始化
void PrintStack(Stack*ps);//打印
void PushStack(Stack*ps, DataType data);//入栈
void PopStack(Stack*ps);//出栈
DataType TopStack(Stack*ps);//取栈顶元素
size_t SizeStack(Stack*ps);//获取栈的大小
int EmptyStack(Stack*ps);//判空
void DestroyStack(Stack*ps);//销毁栈

stack.c

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<Windows.h>
#include<assert.h>
#include"Stack.h"

void IntiStack(Stack*ps, size_t capacity)
{
	assert(ps&&capacity>0);

	ps->top = (DataType*)malloc(sizeof(DataType)*capacity);
	assert(ps->top);
	ps->size = 0;
	ps->capacity = capacity;
}
void PrintStack(Stack*ps)
{
	assert(ps);
	while (EmptyStack(ps) != 0)
	{
		printf("%d \n", TopStack(ps));
		PopStack(ps);
	}
}
void PushStack(Stack*ps, DataType data)
{
	assert(ps);
	if (ps->capacity == ps->size)
	{
		ps->capacity *= 2;
		ps->top = (DataType*)realloc(ps->top, sizeof(DataType)*ps->capacity);
	}
	ps->top[ps->size++] = data;
}
void PopStack(Stack*ps)
{

	assert(ps&&ps->size);
	--ps->size;
}
DataType TopStack(Stack*ps)
{
	assert(ps&&ps->size);
	return ps->top[(ps->size) - 1];
}
size_t SizeStack(Stack*ps)
{
	assert(ps);
	return (ps->size);
}
int EmptyStack(Stack*ps)
{
	assert(ps);
	return (ps->size);
}
void DestroyStack(Stack*ps)
{
	assert(ps);
	ps->capacity = 0;
	ps->size = 0;
	free(ps->top);
	ps = NULL;
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include"Stack.h"
#include<Windows.h>
test()
{
	Stack _stack;
	IntiStack(&_stack,10);
	PushStack(&_stack, 1);
	PushStack(&_stack, 2);
	PushStack(&_stack, 3);
	PushStack(&_stack, 4);
	PrintStack(&_stack);
	printf("%d",SizeStack(&_stack));
}
int main()
{
	test();
	system("pause");
	return 0;
}

链式栈的基本操作：

stack.h

#pragma once
#define _CRT_SECURE_NO_WARNING1
typedef int DataType;
typedef struct Node
{
	DataType data;
	struct Node* _next;
}Node;

Node*BuyNode(DataType value);//创建一个节点
void InitStack(Node**p);//初始化
Node* PushBackStack(Node**p, DataType value);//入栈
void PopBackStack(Node**p);//出栈
Node*TopStack(Node**p);//取栈顶元素
void PrintStack(Node**p);//打印
size_t GetSizeStack(Node**p);//取栈大小

stack.c

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<Windows.h>
#include<assert.h>
#include"Stack.h"

Node*BuyNode(DataType value)
{
	Node*pNewNode = (Node*)malloc(sizeof(Node));
	if (pNewNode != NULL)
	{
		pNewNode->data = value;
		pNewNode->_next = NULL;
		return pNewNode;
	}
	return -1;
}
void IntiStack(Node**p)
{
	assert(p);
	*p = NULL;
}
Node* PushBackStack(Node**p,DataType value)
{
	assert(p);
	if (*p == NULL)//第一次进栈
	{
		*p = BuyNode(value);
		return *p;
	}
	Node* pCur = *p;
	while (pCur->_next!= NULL)
	{
		pCur = pCur->_next;
	}
	Node*pNewNode = BuyNode(value);
	pCur->_next = pNewNode;
	return pNewNode;
}
void PopBackStack(Node**p)
{
	assert(p);
	Node*pCur = *p;
	Node*pPrev = NULL;
	while (pCur->_next != NULL)
	{
		pPrev = pCur;
		(pCur) = pCur->_next;
	}
	free(pCur);
	if (pPrev != NULL)
	{
		pPrev->_next = NULL;
	}
}
Node*TopStack(Node**p)
{
	assert(p);
	Node*pCur = *p;
	while (pCur->_next != NULL)
	{
		pCur = pCur->_next;
	}
	return pCur;
}
size_t GetSizeStack(Node**p)
{
	assert(p);
	size_t count = 0;
	Node*pCur = *p;
	while (pCur!= NULL)
	{
		count++;
		pCur = pCur->_next;
	}
	return count;
}
void PrintStack(Node**p)
{
	assert(p);
	Node*pCur = TopStack(p);
	int count = GetSizeStack(p);
	while (count>1)
	{
		Node*pCur = TopStack(p);
		printf("%d\n", pCur->data);
		PopBackStack(p);
		count--;
	}
	printf("%d\n", TopStack(p)->data);
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include"Stack.h"
#include<Windows.h>
test()
{
	Node* Node;
	IntiStack(&Node);
	PushBackStack(&Node, 1);
	PushBackStack(&Node, 2);
	PushBackStack(&Node, 3);
	PushBackStack(&Node, 4);
	//PopBackStack(&Node);
	PrintStack(&Node);
}
int main()
{
	test();
	system("pause");
	return 0;
}