线性表之三，受限的线性表，栈

　　栈（Stack）是限定仅在表尾进行插入或删除操作的线性表。通常称其表尾为栈顶（top），表头端称为栈底（ bottom）。按栈的存储方式可以分为顺序栈、链式栈。

　　一、顺序表栈

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

#define OVERFLOW -1
#define OK 1
#define ERROR 0
#define STACK_INIT_SIZE 100 //存储空间初始分配量
#define STACKINCREMENT 10//存储空间分配增量

typedef int SElemType,Status;
/* 顺序栈结构体 */
typedef struct {
    SElemType *base; //栈底指针
    SElemType *top; //栈顶指针
    int stacksize;
}SqStack;

/* 构造一个空栈 */
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 GetTop (SqStack S , SElemType &e )
{
    if(S.top == S.base) return ERROR;//栈空 top == base 
    e = *(S.top-1); //top指向的是栈顶元素的下一个位置
    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;//栈空 top == base
    e = *--S.top; //更新栈顶并出栈
    return OK;
}

/* 测试 */
int main()
{
    SqStack S;
    SElemType e;
    InitStack(S);//构造空栈
    for(int i=0; i<10; ++i)
        Push(S,i); //压栈   
    while(Pop(S,e))
        printf("%d
",e);//出栈
    return 0;
}

//浙大数据结构  顺序栈
typedef int Position;
struct SNode {
    ElementType *Data; /* 存储元素的数组 */
    Position Top;      /* 栈顶指针 */
    int MaxSize;       /* 堆栈最大容量 */
};
typedef struct SNode *Stack;
 
Stack CreateStack( int MaxSize )
{
    Stack S = (Stack)malloc(sizeof(struct SNode));
    S->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
    S->Top = -1;
    S->MaxSize = MaxSize;
    return S;
}
 
bool IsFull( Stack S )
{
    return (S->Top == S->MaxSize-1);
}
 
bool Push( Stack S, ElementType X )
{
    if ( IsFull(S) ) {
        printf("堆栈满");
        return false;
    }
    else {
        S->Data[++(S->Top)] = X;
        return true;
    }
}
 
bool IsEmpty( Stack S )
{
    return (S->Top == -1);
}
 
ElementType Pop( Stack S )
{
    if ( IsEmpty(S) ) {
        printf("堆栈空");
        return ERROR; /* ERROR是ElementType的特殊值，标志错误 */
    }
    else 
        return ( S->Data[(S->Top)--] );
}

　　二、链表栈

#include <stdio.h>
#include <malloc.h>
#define OK 1
#define ERROR 0
/* 0.定义结点 */
typedef int SElemType, Status;
typedef struct stack* STACKPTR;
typedef struct stack STACK;
struct stack{
    SElemType e;
    STACKPTR next;
};

/* 1.push */
Status push(STACKPTR *top,SElemType e)
{
    STACKPTR p;
    p = (STACKPTR)malloc(sizeof(STACK));
    if(p == NULL)
        return ERROR;
    
    p->e=e;
    p->next = *top;

    *top = p;
    return OK;
}

/* 2.pop */
Status pop(STACKPTR *top,SElemType *e)
{    
    if(*top == NULL)
        return ERROR;
    
    *e = (*top)->e;
    
    STACKPTR t = *top;
    *top = (*top)->next;
    free(t);    
    return OK;
}

/* 测试代码 */
int main()
{        
    STACKPTR top = NULL;
    SElemType e;
    for(int i=0; i<10; ++i)
        push(&top,i);    
    while(pop(&top,&e))
        printf("%d
",e);
    return 0;
}

//浙大数据结构  链栈
typedef struct SNode *PtrToSNode;
struct SNode {
    ElementType Data;
    PtrToSNode Next;
};
typedef PtrToSNode Stack;
 
Stack CreateStack( ) 
{ /* 构建一个堆栈的头结点，返回该结点指针 */
    Stack S;
 
    S = (Stack)malloc(sizeof(struct SNode));
    S->Next = NULL;
    return S;
}
 
bool IsEmpty ( Stack S )
{ /* 判断堆栈S是否为空，若是返回true；否则返回false */
    return ( S->Next == NULL );
}
 
bool Push( Stack S, ElementType X )
{ /* 将元素X压入堆栈S */
    PtrToSNode TmpCell;
 
    TmpCell = (PtrToSNode)malloc(sizeof(struct SNode));
    TmpCell->Data = X;
    TmpCell->Next = S->Next;
    S->Next = TmpCell;
    return true;
}
 
ElementType Pop( Stack S )  
{ /* 删除并返回堆栈S的栈顶元素 */
    PtrToSNode FirstCell;
    ElementType TopElem;
 
    if( IsEmpty(S) ) {
        printf("堆栈空"); 
        return ERROR;
    }
    else {
        FirstCell = S->Next; 
        TopElem = FirstCell->Data;
        S->Next = FirstCell->Next;
        free(FirstCell);
        return TopElem;
    }
}

　　三、栈的应用举例

　　1、进制转换

　　十进制数N和其它d进制数的转换的算法基于原理： N = (N div d)×d + N mod d， 其中，div 相除取整，mod 相除取余。

　　计算过程是从低位到高位顺序产生d进制数的各个数位，而打印输出，一般来说应从高位到低位进行，恰好和计算过程相反。因此，若将计算过程中得到的d进制数 的各位顺序进栈，则按出栈序列打印输出的即为与输入对应 的d进制数。

    /* 用上面链表栈代码测试 */
    STACKPTR top = NULL;
    SElemType e;
    int n = 1348;//10进制数
    int d = 8; //8进制
    while(n)
    {        
        push(&top,n%d);
        n /= d;
    }        
    while(pop(&top,&e))
        printf("%d",e);