数据结构——栈的顺序存储表示

数据结构作业之五，留作模板保存

#include<string.h>
#include<ctype.h>
#include<malloc.h> // malloc()等
#include<limits.h> // INT_MAX等
#include<stdio.h> // EOF(=^Z或F6),NULL
#include<stdlib.h> // atoi()
#include<io.h> // eof()
#include<math.h> // floor(),ceil(),abs()
#include<process.h> // exit()
#include<iostream> // cout,cin
// 函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
// #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行
typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等
typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSE

typedef int SElemType; // 定义栈元素类型
//栈的顺序存储表示
#define STACK_INIT_SIZE 10 // 存储空间初始分配量
#define STACKINCREMENT 2 // 存储空间分配增量
typedef struct
{
    SElemType *base; // 在栈构造之前和销毁之后，base的值为NULL
    SElemType *top; // 栈顶指针
    int stacksize; // 当前已分配的存储空间，以元素为单位
    int length;
} SqStack; // 顺序栈
// 顺序栈的基本操作（9个）
Status InitStack(SqStack &S)
{
    /// 构造一个空栈S
    S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
    if(!S.base)exit(OVERFLOW);
    S.top=S.base;
    S.stacksize=STACK_INIT_SIZE;
    S.length=0;
    return OK;
}

Status DestroyStack(SqStack &S)
{
    /// 销毁栈S，S不再存在
    S.length=0;
    S.base=S.top=NULL;
    S.stacksize=0;

    free(S.base);
    return OK;
}

Status ClearStack(SqStack &S)
{
    /// 把S置为空栈
    S.length=0;
    S.base=S.top=NULL;
    return OK;
}

Status StackEmpty(SqStack S)
{
    /// 若栈S为空栈，则返回TRUE，否则返回FALSE
    if(S.base==S.top)return TRUE;
    else return FALSE;
}

int StackLength(SqStack S)
{
    /// 返回S的元素个数，即栈的长度
    return S.length;
}

Status GetTop(SqStack S,SElemType &e)
{
    /// 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
    if(S.top==S.base)return ERROR;
    e=*(S.top-1);
    return OK;
}

Status Push(SqStack &S,SElemType e)
{
    /// 插入元素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;
    S.length++;
    return OK;
}

Status Pop(SqStack &S,SElemType &e)
{
    /// 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
    if(S.top==S.base) return ERROR;
    e=*--S.top;
    S.length--;
    return OK;
}

Status StackTraverse(SqStack S,Status(*visit)(SElemType))
{
    // 从栈底到栈顶依次对栈中每个元素调用函数visit()。
    // 一旦visit()失败，则操作失败
    int j=1;
    for(SElemType *i=S.top-1; j<=S.length; i--,j++)
    {
        visit(*(i));
    }
}


Status visit(SElemType c)
{
    printf("%d ",c);
    return OK;
}

void conversion(int n,int m)
{
    ///进制转换函数
    SqStack S;
    SElemType e;
    InitStack(S);
    while(n)
    {
        Push(S,n%m);
        n=n/m;
    }
    while(!StackEmpty(S))
    {
        Pop(S,e);
        printf("%d",e);
    }
    printf("\n");
}
int main()
{
    char k='1';
    int j;
    SqStack s;
    SElemType e;
    if(InitStack(s)==OK)
        for(j=1; j<=12; j++)
            Push(s,j);
    printf("栈中元素依次为：");
    StackTraverse(s,visit);
    Pop(s,e);
    printf("弹出的栈顶元素 e=%d\n",e);
    printf("栈空否：%d(1:空 0:否)\n",StackEmpty(s));
    GetTop(s,e);
    printf("栈顶元素 e=%d 栈的长度为%d\n",e,StackLength(s));
    ClearStack(s);
    printf("清空栈后，栈空否：%d(1:空 0:否)\n",StackEmpty(s));
    DestroyStack(s);
    printf("销毁栈后，s.top=%u s.base=%u s.stacksize=%d\n",s.top,s.base, s.stacksize);
    while(k!='0')scanf("%c",&k);
}