数据结构（五）（顺序）栈实现的功能

栈是一个特殊的线性表，只能在一端操作；
栈顶（top）：允许操作 的一端；
栈底（bottom）：不允许操作的一端
栈的性质： 先进后出，后进先出

.1.栈是限定仅在表尾进行插入和删除操作的线性表；又称 后进先出的线性表。LIFO结构。
栈顶top：允许插入和删除的一端；
栈底bottom：另外一端；
2. 空栈：不含任何数据元素的栈；top=-1;
3. 栈的操作：
进栈，压栈，入栈：栈的插入操作；
出栈，弹栈：栈的删除操作；
栈中有一个元素时，top=0

头文件

#ifndef SEQUENCESTACK_H
#define SEQUENCESTACK_H

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

#define SIZE 10
#define SUCCESS 10000
#define FAILURE 10001
#define TRUE 10002
#define FALSE 10003

struct SequenceStack    //表示栈的信息
{
	int *data;   //定义栈中存放的元素
	int top;    //定义栈顶（栈的长度）
};
typedef struct SequenceStack Stack;

int InitStack(Stack *s);
int push(Stack *s, int e);
int GetTop(Stack s);
int EmptyStack(Stack s);
int pop(Stack *s);
int ClearStack(Stack *s);
int DestroyStack(Stack *s);

#endif

调用子函数，函数文件

#include"SequenceStack.h"
/*
函数描述：栈的初始化
函数参数：栈的地址
函数返回值：失败返回FAILURE，成功返回SUCCESS
*/
int InitStack(Stack *s)
{
	if(NULL == s)
	return FAILURE;
	s -> data = (int  *)malloc(sizeof(int)* SIZE);
	if(NULL == s -> data)
	return FAILURE;
	s -> top = -1;  // 空栈，里面没有元素。
	return SUCCESS;
}
/*
函数描述：元素进栈
函数参数：栈空间的地址，输入的元素
函数返回值：失败返回FAILURE，成功返回SUCCESS
*/
int push(Stack *s, int e)
{
	if(NULL == s)
	return FAILURE;
	if(s -> top == SIZE -1) //判断栈是否满了（SIZE 10，有十个元素，下标从0到9，所以总数要减一）
	return FAILURE;
	if(NULL == s -> data) //如果指针s指向的数据为空，返回失败。防止空指针发生错误
	return FAILURE;

	s -> data[++(s -> top)] = e;  //进栈一个元素，栈顶向上移动一位
	return SUCCESS;
}
/*
函数描述： 获取栈顶元素
函数参数：栈空间
函数返回值：失败返回SUCCESS，成功返回栈顶元素
*/
int GetTop(Stack s)
{
	if(s.top == -1)  //空栈
	return FAILURE;
	return s.data[s.top];
}
/*
函数描述：判断栈是否为空
函数参数：栈空间
函数返回值：不空返回FALES，空返回TRUE；
*/
int EmptyStack(Stack s)
{
	return (s.top == -1)? TRUE : FALSE;
}
/*
函数描述：栈内元素出栈
函数参数：栈空间的地址
函数返回值：失败返回FAILURE，成功返回出栈元素
*/
int pop(Stack *s)
{
	if(NULL == s)
	return FAILURE;
	if(s.top == -1)
	return FAILURE;

	int e = s ->data[s -> top];
	s -> top--;  // 栈空间后进先出，栈顶指针减一，就出栈一个元素
	return e;
}
/*
函数描述：清空栈空间
函数参数：栈空间的地址
函数返回值：失败返回FAILURE，成功返回SUCCESS
*/
int ClearStack(Stack *s)
{
	if(NULL == s)
	return FAILURE;
	s -> top = -1;  //只需把栈顶指针赋值为-1即可
	return SUCCESS;
}
/*
函数描述：清除栈空间
函数参数：栈空间的地址
函数返回值:成功返回SUCCESS，失败返回FAILURE
*/
int DestoryStack(Stack *s)
{
	if(NULL == s)
	return FAILURE;

	free(s -> data);
	s -> data = NULL;
	return SUCCESS;
}

主函数执行文件

#include"SequenceStack.h"
int main()
{
	srand (time(NULL));
	Stack stack;
	int ret;

	ret = InitStack(&stack);
	if(SUCCESS == ret)
	{
		printf("初始化成功!\n");
	}
	else
	{
		printf("初始化失败\n");
	}
	ret = EmptyStack(stack);
	if(TRUE == ret)
	{
		printf("栈为空\n");
	}
	else
	{
		printf("栈不为空!\n");
	}
	
	int i ,num;
	for(i = 0; i < 15; i++)
	{
		num = rand() %10;
		ret = push(&stack, num);
		if(FAILURE == ret)
		{
			printf("%d进栈失败!\n", num);
		}
		else
		{	
			printf("%d进栈成功!\n", num);
		}
	}
	ret = GetTop(stack);
	if(FAILURE == ret)
	{	
		printf("栈顶元素不存在！\n");
	}
	else
	{	
		printf("栈顶元素是%d\n", ret);
	}
	ret = EmptyStack(stack);
	if(TRUE == ret)
	{
		printf("栈为空\n");
	}
	else
	{
		printf("栈不为空!\n");
	}
	for(i = 0; i < 13; i++)
	{
		ret = pop(&stack);
		if(FAILURE == ret)
		{
			printf("出栈失败！\n");
		}
		else
		{
			printf("%d出栈成功\n"， ret);
		}
	}
	ret = ClearStack(&stack);
	if(FAILURE == ret)
	{
		printf("清空失败\n");
	}
	else
	{
		printf("清空成功!\n");
	}
	ret = GetTop(stack);
	if(FAILURE == ret)
	{	
		printf("栈顶元素不存在！\n");
	}
	else
	{	
		printf("栈顶元素是%d\n", ret);
	}
	ret = DestoryStack(&stack);
	if(SUCCESS == ret)
	{
		printf("销毁成功！\n");
	}
	else
	{
		printf("销毁失败！\n");
	}
	for(i = 0; i < 15; i++)
	{
		num = rand() %10;
		ret = push(&stack, num);
		if(FAILURE == ret)
		{
			printf("%d进栈失败!\n", num);
		}
		else
		{	
			printf("%d进栈成功!\n", num);
		}
	}
	return 0;
}