链栈的基本操作

栈是限定仅在表尾进行插入和删除操作的线性表。表尾端称为栈顶，表头端称为栈底。栈又称为后进先出的线性表。

示意图：

栈的基本操作包括：

void IninStack()
	操作结果：构造一个栈并返回;
	
void DestroyStack(PStack stack)
	初始条件：栈stack已存在;
	操作结果：栈stack被销毁;
	
void ClearStack(PStack stack)
	初始条件：栈Satck已存在;
	操作结果：将栈Stack清为空栈;
	
int StackEmpty(PStack stack)
	初始条件：栈Stack存在;
	操作结果：判断栈是否为空，如果是，则返回1，否则返回0;
	
int StackLength(PStack stack)
	初始条件：栈Stack存在;
	操作结果：返回栈stack的长度;
	
ElemType GetTop(PStack stack)
	初始条件：栈stack存在且非空;
	操作结果：返回栈Stack的栈顶元素，不修改栈顶指针;
	
void Push(PStack stack,ElemType e)
	初始条件：栈stack存在;
	操作结果：插入新的元素为e的栈顶结点;
	
void Pop(PStack stack, ElemType &e)
	初始条件：栈stack存在且非空;
	操作结果：删除栈stack的栈顶元素，并用e返回其值;
	
void StackTraverse(PStack stack)
	初始条件：栈stack存在且非空;
	操作结果：从栈底到栈顶依次催栈stack的栈顶元素的每个数据进行访问;

代码演示：

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>

/*
	时间：2020年11月13日19:55:38
*/


#define  ElemType int 

//栈结点的数据类型
typedef struct StackNode
{
	ElemType data;
	struct StackNode* next;
}STACKNODE, *PSTACKNODE;

//栈的数据类型
typedef struct stack
{
	int size;
	struct StackNode* top;
}STACK, * PSTACK;

//初始化栈，创建栈
PSTACK InitStack()
{
	PSTACK stack = (PSTACK)malloc(sizeof(STACK));
	stack->size = 0;
	stack->top = NULL;
	return stack;
}

//判断栈是否为空
int StackEmpty(PSTACK stack)
{
	if (stack == NULL || stack->top == NULL)
	{
		return 1;
	}
	return 0;
}

//返回栈的长度
int StackLength(PSTACK stack)
{
	if (stack == NULL)
	{
		return -1;
	}
	return stack->size;
}

//返回栈顶元素
ElemType GetTop(PSTACK stack)
{
	if (stack == NULL || stack->top == NULL)
	{
		return -11111;
	}
	return stack->top->data;
}

//压栈
void Push(PSTACK stack, ElemType data)
{
	//链栈进栈不存在栈满的情况，不需要判断栈是否已满
	PSTACKNODE newNode = (PSTACKNODE)malloc(sizeof(STACKNODE));
	newNode->data = data;
	newNode->next = stack->top;
	stack->top = newNode;
	stack->size++;
	return;
}

//出栈
void Pop(PSTACK stack, ElemType * data)
{
	//链栈出栈需要判断是否栈空
	if (stack == NULL || stack->top == NULL)
	{
		printf("\n栈已空，无法出栈！\n");
		return;
	}
	PSTACKNODE temp = stack->top;
	*data = temp->data;
	stack->top = temp->next;
	stack->size--;
	free(temp);
	temp = NULL;
	return;
}

//形参为某个栈的头栈顶元素，利用递归遍历栈的元素，有些些缺点，无法判断栈是否存在，本函数假定栈存在
void StackTraverse_1(PSTACKNODE PNode)
{
	//从栈底遍历到栈顶元素
	if (PNode == NULL)
		return;
	else
	{
		StackTraverse_1(PNode->next);
		printf("%d\t", PNode->data);
	}
	return;
	/*
	//从栈顶遍历到栈底
	else
	{
		printf("%d\t",PNode->data);
		StackTraverse_1(PNode->next);
	}
	return;
	*/
}

//形参为某个栈，利用循环对栈元素进行遍历，从栈底到栈顶
void StackTraverse_2(PSTACK stack)
{
	if (stack->top == NULL)
	{
		printf("栈为空！\n");
		return;
	}
	else if (stack == NULL)
	{
		printf("栈不存在！\n");
		return;
	}
	int i = 0, j = stack->size;
	PSTACKNODE pMove = NULL;

	printf("\n");
	while (j > 0)
	{
		i = 1;
		pMove = stack->top;
		while (i < j)
		{
			pMove = pMove->next;
			i++;
		}
		j--;
		printf("%d\t", pMove->data);
	}
	printf("\n");
	return;
}

//销毁栈，栈已销毁
void DestrotStack(PSTACK stack)
{
	if (stack == NULL)
		return;
	PSTACKNODE temp = NULL;
	while (stack->top != NULL)
	{
		temp = stack->top->next;
		free(stack->top);
		stack->top = temp;
	}
	free(stack);
	stack = NULL;
	return;
}

//清空栈,栈还存在，栈顶指针为空
void ClearStack(PSTACK stack)
{
	if (stack == NULL || stack->top == NULL)
	{
		return;
	}
	while (stack->top != NULL)
	{
		PSTACKNODE temp = stack->top->next;
		free(stack->top);
		stack->top = temp;
	}
	return;
}

int main(int argc, char* argv[])
{
	//创建一个栈
	PSTACK stack = InitStack();

	//压栈5次
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		Push(stack, i);
	}
	//利用递归遍历栈
	StackTraverse_1(stack->top);
	printf("\n");

	//获取栈顶元素
	printf("栈顶元素为%d\n", GetTop(stack));

	//获取栈的长度
	printf("栈的长度为%d\n", StackLength(stack));

	//出栈3次
	for (i = 0; i < 3; i++)
	{
		ElemType temp;
		Pop(stack, &temp);
	}
	//利用循环遍历栈
	StackTraverse_2(stack);
	printf("栈的长度为%d\n\n", StackLength(stack));

	//清空栈
	ClearStack(stack);
	StackTraverse_2(stack);


	return 0;
}