【数据结构】栈的顺序表示

本文部分内容来自《数据结构（C语言版）严蔚敏著》，侵删歉。
待完善中...

---

栈的顺序表示

栈的顺序表示，即用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，同时附设一个指针指示当前栈顶的位置。将这种表示称为栈的顺序存储结构，具有这种顺序存储结构的栈称为顺序栈。

描述顺序栈与顺序表一样，通常使用数组，根据数组空间的分配方式分为两种：静态分配、动态分配。

静态分配

#define MAXSIZE 1000  //定义栈中元素的最大个数
typedef struct{
    ElemType data[MAXSIZE];    //存放栈中元素
    int top;                   //栈顶指针,指向栈顶元素
}SqStack;

动态分配

#define STACK_INIT_SIZE 100 //存储空间初始分配量
#define STACKINCREMENT 10   //存储空间分配增量
typedef struct{
    ElemType *base; //栈底地址
    ElemType *top;  //栈顶指针
    int stacksize   //当前分配的存储容量（以sizeof(ElemType)为单位）
}

---

顺序栈上基本操作的实现

对于静态顺序栈，常设置初始时S.top=-1，也可以设置成S.top=0，下面的操作均参考前者。

1、初始化

//静态分配顺序栈
Status InitStack(SqStack &S){
    S.top=-1;
}

//动态分配顺序栈
Status InitStack(SqStack &S){
    //构造一个空栈S
    S.base=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType));
    if(!S.base) exit(OVERFLOW);    //存储分配失败
    S.top=S.base;
    S.stacksize=STACK_INIT_SIZE;
    return OK;
}

2、销毁

//静态顺序栈 无需手动销毁
 
//动态顺序栈
Status DestroyStack(SqStack &S){
    free(S.base);
    S.base=S.top=NULL;
    return OK;
}

3、清空

//静态顺序栈
Status ClearStack(SqStack &S){
    S.top=-1;
    return OK;
}

//动态顺序栈
Status ClearStack(SqStack &S){
    S.top=S.base;
    return OK;
}

4、判空

//静态顺序栈
Status StackEmpty(SqStack S){
    if(S.top==-1) return TRUE;
    return FALSE;
}

//动态顺序栈
Status StackEmpty(SqStack S){
    if(S.top==S.base) return TRUE;
    return FALSE;
}

栈空条件：
对于静态顺序栈来说，栈空条件为S.top==-1。（若初始化S.top==0，则栈空条件为S.top==0）
对于动态顺序栈来说，栈空条件为

5、计算栈长

//静态顺序栈
int StackLength(SqStack S){
    return S.top+1;
}

//动态顺序栈
int StackLength(SqStack S){
    return S.top-S.base;
}

6、获取栈顶元素

//静态顺序栈
Status GetTop(SqStack S, ElemType &e){
    //若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
    if(S.top==-1) return ERROR;
    e=S.data[S.top];
    return OK;
}

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

7、入栈

//静态顺序栈
Status Push(SqStack &S, ElemType e){
    if(S.top==MAXSIZE-1) return ERROR;
    S.data[++S.top]=e;
    return OK;
}

//动态顺序栈
Status Push(SqStack &S, ElemType e){
    //插入元素e为新的栈顶元素
    if(S.top-S.base>=S.stacksize){ //栈慢，追加存储空间
        S.base=(ElemType*)realloc(S.base, (S.stacksize+STACKINCREMENT)*sizeof(ElemType));
        if(!S.base) exit(OVERFLOW); //存储分配失败
        S.top=S.base+S.stacksize;
        S.stacksize+=STACKINCREMENT;
    }
    *S.top++=e;
    return OK;
}

8、出栈

//静态顺序栈
Status Pop(SqStack &S, ElemType &e){
    //若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
    if(S.top==-1) return ERROR;
    e=S.data[S.top--];
    return OK;
}

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

9、遍历

//静态顺序栈
Status StackTraverse(SqStack S, Status (*Visit)(ElemType e)){
    //从栈底到栈顶依次对S的每个数据元素调用函数Visit()
    for(i=0; i<=top; i++){
        (*Visit)(S.data[i]);
    }
    return OK;
}

//动态顺序栈
Status StackTraverse(SqStack S, Status (*Visit)(ElemType e)){
    while(S.base!=S.top){
        (*Visit)(*S.base++);
    }
    return OK;
}