栈

栈的动态顺序存储表示----先进后出
采用动态一维数组来存储栈。所谓动态，指的是栈的大小可以根据需要增加。
◆ 用bottom表示栈底指针，栈底固定不变的；栈顶则随着进栈和退栈操作而变化。用top(称为栈顶指针)指示当前栈顶位置。
◆ 用top=bottom作为栈空的标记，每次top指向栈顶数组中的下一个存储位置。
◆ 结点进栈：首先将数据元素保存到栈顶(top所指的当前位置)，然后执行top加1，使top指向栈顶的下一个存储位置;
◆ 结点出栈：首先执行top减1，使top指向栈顶元素的存储位置，然后将栈顶元素取出。

1 栈的类型定义

#define  STACK_SIZE  100    /*  栈初始向量大小  */
#define STACKINCREMENT 10   /*存储空间分配增量  */
#typedef  int  ElemType ;
typedef struct sqstack
{  
     ElemType  *bottom;     /*  栈不存在时值为NULL  */
     ElemType  *top;      /*  栈顶指针  */
     int   stacksize ;     /* 当前已分配空间，以元素为单位  */
}SqStack ;

2  栈的初始化

Status Init_Stack(void)
{   
    SqStack  S ;
    S.bottom=(ElemType *)malloc(STACK_SIZE *sizeof(ElemType));
    if (! S.bottom) 
        return  ERROR;
    S.top=S.bottom ;    /*  栈空时栈顶和栈底指针相同  */
    S. stacksize=STACK_SIZE; 
    return OK ;
}

3压栈

Status push(SqStack S , ElemType  e)
{  
    if(S.top-S.bottom>=S. stacksize-1) 
    {   
        S.bottom=(ElemType *)realloc((S. STACKINCREMENT+STACK_SIZE) *sizeof(ElemType));   /*  栈满，追加存储空间  */
        if (! S.bottom) 
            return  ERROR; 
        S.top=S.bottom+S. stacksize ;
        S. stacksize+=STACKINCREMENT ;
    }  
    *S.top=e;  S.top++ ; /* 栈顶指针加1，e成为新的栈顶 */
    return OK;
}

4.弹栈

Status pop( SqStack  S, ElemType  &e )/*弹出栈顶元素*/
{  
    if ( S.top== S.bottom )  
        return ERROR ;       /*  栈空，返回失败标志  */
    e=*--S. top ;  
    return  OK ; 
} 

栈的静态顺序存储表示
采用静态一维数组来存储栈。
栈底固定不变的，而栈顶则随着进栈和退栈操作变化的，
◆ 栈底固定不变的；栈顶则随着进栈和退栈操作而变化，用一个整型变量top(称为栈顶指针)来指示当前栈顶位置。
◆ 用top=0表示栈空的初始状态，每次top指向栈顶在数组中的存储位置
◆ 结点进栈：首先执行top加1，使top指向新的栈顶位置，然后将数据元素保存到栈顶(top所指的当前位置)。
◆ 结点出栈：首先把top指向的栈顶元素取出，然后执行top减1，使top指向新的栈顶位置。
若栈的数组有Maxsize个元素，则top=Maxsize-1时栈满。

1   栈的类型定义
# define  MAX_STACK_SIZE  100      /*  栈向量大小  */
# typedef  int  ElemType ;
typedef struct  sqstack
{  
    ElemType   stack_array[MAX_STACK_SIZE] ;
    int  top;
    int  button
}SqStack ;

2 栈的初始化
SqStack Init_Stack(void)
{   
    SqStack  S ;
    S.bottom=S.top=0 ;  return(S) ;
}

3  压栈(元素进栈)
Status push(SqStack S , ElemType  e)/*  使数据元素e进栈成为新的栈顶  */   
{  
    if  (S.top==MAX_STACK_SIZE-1) 
        return  ERROR;      /*  栈满，返回错误标志    */
    S.top++ ;      /*  栈顶指针加1  */
    S.stack_array[S.top]=e  ;   /* e成为新的栈顶  */
    return OK;        /*  压栈成功    */
}

4  弹栈(元素出栈)
Status  pop( SqStack   S, ElemType  *e )  /*弹出栈顶元素*/
{  
    if ( S.top==0 )
        return ERROR ;       /*  栈空，返回错误标志    */
    *e=S.stack_array[S.top] ;  
    S.top-- ;  
    return OK ;  
}

 

栈的链式存储表示
栈的链式存储结构称为链栈，是运算受限的单链表。其
插入和删除操作只能在表头位置上进行

链栈的结点类型说明如下：
typedef  struct  Stack_Node
{  
    ElemType   data ;
    struct Stack_Node  *next ;
} Stack_Node ;

(1) 栈的初始化
Stack_Node  *Init_Link_Stack(void)
{   
    Stack_Node  *top ;
    top=(Stack_Node  *)malloc(sizeof(Stack_Node )) ;
    top->next=NULL ; 
    return(top) ;
}

(2)  压栈(元素进栈)
Status push(Stack_Node *top , ElemType  e)
{   
    Stack_Node  *p ;
    p=(Stack_Node  *)malloc(sizeof(Stack_Node)) ; 
    if (!p)  return  ERROR; /*  申请新结点失败，返回错误标志 */
    p->data=e ; 
    p->next=top->next  ; 
    top->next=p ;    /*  钩链  */
    return OK;
}

(3)  弹栈(元素出栈)
Status pop(Stack_Node  *top , ElemType *e)/*  将栈顶元素出栈  */
{   
    Stack_Node  *p ;
    ElemType  e ;
    if  (top->next==NULL )
        return ERROR ;    /*  栈空，返回错误标志    */
    p=top->next ; e=p->data ;    /*  取栈顶元素  */
    top->next=p->next ;     /*  修改栈顶指针  */
    free(p) ; 
    return OK ;
}

 

转载于:https://www.cnblogs.com/lcpholdon/p/4054625.html