线性表seqList类及其父类list，模板类

　　栈（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-); //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=; i<; ++i)
         Push(S,i); //压栈
     while(Pop(S,e))
         printf("%d\n",e);//出栈
     return ;
 }

 //浙大数据结构 \ 顺序栈
 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 = -;
     S->MaxSize = MaxSize;
     return S;
 }

 bool IsFull( Stack S )
 {
     return (S->Top == S->MaxSize-);
 }

 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 == -);
 }

 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=; i<; ++i)
         push(&top,i);
     while(pop(&top,&e))
         printf("%d\n",e);
     return ;
 }

 //浙大数据结构 \ 链栈
 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 = ;//10进制数
    int d = ; //8进制
    while(n)
    {
        push(&top,n%d);
        n /= d;
    }
    while(pop(&top,&e))
        printf("%d",e);