顺序栈和链栈的基本操作

SqStack.h

//**********一些预定义常量和类型***********

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2 
typedef int Status;

//**********栈的顺序存储表示***************

#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef int SElemType;
typedef struct
{
  SElemType *base;
  SElemType *top;
  int stacksize;
}SqStack;

//**********基本操作的函数原型说明**********

Status InitStack(SqStack *S);
//构造一个空栈S
Status DestroyStack(SqStack *S);
//销毁栈S，S不再存在
Status ClearStack(SqStack *S);
//把S置为空栈
Status StackEmpty(SqStack S);
//若栈S为空栈，则返回TRUE,否则返回FALSE
int StackLength(SqStack S);
//返回S的元素个数，即栈的长度
Status GetTop(SqStack S,SElemType *e);
//若栈不空，则用*e返回S的栈顶元素，并返回OK；否则返回ERROR
Status Push(SqStack *S,SElemType e);
//插入e为新的栈顶元素
Status Pop(SqStack *S,SElemType *e);
//若栈不空，则删除S的栈顶元素，用*e返回其值，并返回OK；否则返回ERROE
Status StackTraverse(SqStack S);
//从栈顶到栈底遍历栈

//**********基本操作的算法描述部分************

//初始化
Status InitStack(SqStack *S)
{
  S->base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
  if(!S->base) exit(OVERFLOW);
  S->top=S->base;
  S->stacksize=STACK_INIT_SIZE;
  return OK;
}

//销毁
Status DestroyStack(SqStack *S)
{
  int i;
  for(i=1;i<=S->stacksize;i++)
    free(S->base++);
  S->base=S->top=NULL;
  S->stacksize=0;
  return OK;
}

//置空
Status ClearStack(SqStack *S)
{
  S->top=S->base;
  return OK;
}

//判空
Status StackEmpty(SqStack S)
{
  if(S.top==S.base)
    return TRUE;
  else
    return FALSE;
}

//测长度
int StackLength(SqStack S)
{
  return S.top-S.base;
}

//取栈顶元素
Status GetTop(SqStack S,SElemType *e)
{
  if(S.top==S.base) return ERROR;
  *e=*(S.top-1);
  return OK;
}

//入栈
Status Push(SqStack *S,SElemType e)
{
  if(S->top-S->base>=S->stacksize)
  {
    //栈满，追加存储空间
	S->base=(SElemType *)realloc(S->base,
	                                    (S->stacksize+STACKINCREMENT)*sizeof(SElemType));
	if(!S->base) exit(OVERFLOW);
	S->top=S->base+S->stacksize;
	S->stacksize+=STACKINCREMENT;
  }
  *S->top++=e;
  return OK;
}

//出栈
Status Pop(SqStack *S,SElemType *e)
{
  if(S->top==S->base) return ERROR;
  *e=*--S->top;
  return OK;
}

//遍历
Status StackTraverse(SqStack S)
{
  if(StackEmpty(S)) printf("此时栈为空栈!\n");
  for(S.top--;S.top>S.base;S.top--)
    printf("%d ",*S.top);
  printf("%d\n",*S.top);
  return OK;
}

LinkStack.h

//**********一些预定义常量和类型***********

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2 
typedef int Status;

//**********栈的链式存储表示***************
//没有头结点
typedef int SElemType;

//结点结构
typedef struct StackNode
{
  SElemType data;
  struct StackNode *next;
}StackNode;

//链栈结构
typedef struct LinkStack
{
  struct StackNode *top;
  int count;
}LinkStack;

//**********基本操作的函数原型说明**********

Status InitStack(LinkStack *S);
//构造一个空栈S
Status DestroyStack(LinkStack *S);
//销毁栈S，S不再存在
Status ClearStack(LinkStack *S);
//把S置为空栈
Status StackEmpty(LinkStack S);
//若栈S为空栈，则返回TRUE,否则返回FALSE
int StackLength(LinkStack S);
//返回S的元素个数，即栈的长度
Status GetTop(LinkStack S,SElemType *e);
//若栈不空，则用*e返回S的栈顶元素，并返回OK；否则返回ERROR
Status Push(LinkStack *S,SElemType e);
//插入e为新的栈顶元素
Status Pop(LinkStack *S,SElemType *e);
//若栈不空，则删除S的栈顶元素，用*e返回其值，并返回OK；否则返回ERROE
Status StackTraverse(LinkStack S);
//从栈顶到栈底遍历栈

//**********基本操作的算法描述部分************

//初始化
Status InitStack(LinkStack *S)
{
  S->top=NULL;
  S->count=0;
  return OK;
}

//销毁
Status DestroyStack(LinkStack *S)
{
  StackNode *p=S->top;
  for(S->count;S->count>0;S->count--)
  {
    S->top=p->next;
	free(p);
	p=S->top;
  }
  S->count=0;
  return OK;
}

//置空
Status ClearStack(LinkStack *S)
{
  S->top=NULL;
  S->count=0;
  return OK;
}

//判空
Status StackEmpty(LinkStack S)
{
  if(!S.count)
    return TRUE;
  else
    return ERROR;
}

//测长度
int StackLength(LinkStack S)
{
  return S.count;
}

//取栈顶元素
Status GetTop(LinkStack S,SElemType *e)
{
  if(!S.count) return ERROR;
  *e=S.top->data;
  return OK;
}

//入栈
Status Push(LinkStack *S,SElemType e)
{
  StackNode *p=(StackNode *)malloc(sizeof(StackNode));
  p->data=e;
  p->next=S->top;
  S->top=p;
  S->count++;
  return OK;
}

//出栈
Status Pop(LinkStack *S,SElemType *e)
{
  if(!S->count)
    return ERROR;
  StackNode *p=S->top;
  *e=S->top->data;
  S->top=p->next;
  free(p);
  S->count--;
  return OK;
}

//遍历
Status StackTraverse(LinkStack S)
{
  while(S.top)
  {
    printf("%d ",S.top->data);
	S.top=S.top->next;
  }
  return OK;
}

 

主函数文件

#include<stdio.h>
#include<stdlib.h>
#include"SqStack.h"
#include"LinkStack.h"
int main()
{
  SqStack Q;//LinkStack Q;
  SElemType x,y;
  int number;
do
  {
    printf("\n\n\t主菜单\n\n");
	printf("%3c1%4c初始化\n",' ',' ');
	printf("%3c2%4c销毁\n",' ',' ');
	printf("%3c3%4c置空\n",' ',' ');
	printf("%3c4%4c判空\n",' ',' ');
	printf("%3c5%4c测长度\n",' ',' ');
	printf("%3c6%4c取栈顶元素\n",' ',' ');
	printf("%3c7%4c入栈\n",' ',' ');
	printf("%3c8%4c出栈\n",' ',' ');
	printf("%3c9%4c遍历\n\n",' ',' ');
	printf("请输入您的选择（1-8）：");
	scanf("%d",&number);//第一次输入必须为1，即必须初始化

	switch(number)
	{
	  case 1:
	  {
	    InitStack(&Q);
		printf("栈已初始化，此时栈为空栈！\n");break;
	  }
	  case 2:
	  {
	    DestroyStack(&Q);
		printf("栈已销毁，此时栈不存在！\n");break;
	  }
	  case 3:
	  {
	    ClearStack(&Q);
		printf("栈已被置空，此时栈为空栈！\n");break;
	  }
	  case 4:
	  {
	    if(StackEmpty(Q))
		{
			printf("此时栈为空栈！\n");break;
		}
		else
		{
			printf("此时栈不是空栈！\n");break;
		}
	  }
	  case 5:
	  {
	    printf("栈的长度为%d\n",StackLength(Q));break;
	  }
	  case 6:
	  {
	    GetTop(Q,&x);
		printf("此时栈顶元素为：%d\n",x);break;
	  }
	  case 7:
	  {
	    printf("请输入入栈元素：");
		scanf("%d",&y);
	    Push(&Q,y);
		printf("此时从栈顶到栈底遍历栈，得到如下序列：\n");
		StackTraverse(Q);break;
	  }
	  case 8:
	  {
	    Pop(&Q,&x);
		printf("出栈元素为：%d\n",x);
		printf("此时从栈顶到栈底遍历栈，得到如下序列：\n");
		StackTraverse(Q);break;
	  }
	  case 9:
	  {
	    printf("此时从栈顶到栈底遍历栈，得到如下序列：\n");
		StackTraverse(Q);break;
	  }
	}
  }while(number<=9);
  return 0;
}

注：1、参考严蔚敏版教材

       2、vc6.0环境下运行（顺序栈销毁时出错，暂未找到错误）

       3、遍历为从栈顶到栈底遍历