基于数组或链表的堆栈实现

本文使用C语言，给出了堆栈的两种实现：基于数组和基于链表的实现方式。

堆栈是一种常用的数据结构，具有“后进先出（Last In First Out）”的特性，常用来进行函数调用时候的参数传递，解决递归函数书的非递归实现，表达式中的括号匹配等问题。堆栈的常用操作如下：

createStack(st)：建立一个空栈

push(st, x)：将元素x压入栈st当中，使之成为栈顶元素

pop(st,x)：当栈非空时，将栈顶元素弹出，并赋值给x

top(st)：当栈非空时，返回栈顶元素的值

isEmpty(st)：判断栈st是否为空


#include <stdio.h>


#include <assert.h>


#include <stdlib.h>




#define EleType int


#define DEFAULT_SIZE 100






/**//*---------array-based stack--------------*/


#if defined(ARRAY_BASED_STACK)




typedef struct Stack_t ...{


int top;


int capacity;




EleType *container;


}Stack;




int createStack(Stack *st, int c)




...{


if(c<0)


c = DEFAULT_SIZE;


st->container = (EleType*)malloc(c*sizeof(EleType));


if(NULL == st->container) return 0;


st->capacity = c;


st->top = -1;


return 1;


}


int destoryStack(Stack *st)




...{




if(st)...{


st->top = -1;


free(st->container);


st->container = NULL;


}


return 1;


}


int isEmpty(Stack *st)




...{


if(-1 == st->top)


return 1;


else


return 0;


}


EleType top(Stack *st)




...{


return st->container[st->top];


}


int push(Stack *st, EleType e)




...{




if((st->top + 1) == st->capacity) ...{


EleType *tmp = st->container;


st->container = (EleType*)malloc(st->capacity * 2 *sizeof(EleType));


if(!(st->container)) return 0;


st->capacity <<= 1;


int i;


for(i=0; i<st->top; i++)


st->container[i] = tmp[i];


free(tmp);


}


st->top ++;


st->container[st->top] = e;




return 1;


}


int pop(Stack *st, EleType *eptr)




...{




if(-1 == st->top)...{


return 0;


}




else ...{


st->top --;


*eptr = st->container[st->top+1];




if(st->top < (st->capacity>>1)) ...{


EleType *tmp = (EleType*)malloc((st->capacity/2) *sizeof(EleType));




if(tmp) ...{


int i;


for(i=0; i<st->top; i++)


tmp[i] = st->container[i];


free(st->container);


st->container = tmp;


}


}


return 1;


}


}


#endif




/**//*------------link-based stack-------------*/




typedef struct Element_t...{


void *data;


struct Element_t *next;


}Element;




int createStack(Element **st);


int destoryStack(Element **st);


int push(Element **st, void *data);


int pop(Element **st, void **data);


int isEmpty(Element **st);


void * top(Element **st);




int createStack(Element **st)




...{


*st = NULL;


return 1;


}


int destoryStack(Element **st)




...{


Element *next = NULL;




while(*st)...{


next = (*st)->next;


free(*st);


*st = next;


}


return 1;


}


int push(Element **st, void *data)




...{


Element *tmp = (Element*)malloc(sizeof(*tmp));


if(!tmp)


return 0;




else ...{


tmp->data = data;


tmp->next = *st;


(*st)->next = tmp;


return 1;


}


}


int pop(Element **st, void **data)




...{


if(!(*st))


return 0;




else ...{


Element *t = *st;


*data = t->data;


*st = t->next;


free(t);


return 1;


}


}


int isEmpty(Element **st)




...{


if(!(*st))


return 0;


else


return 1;


}


void* top(Element **st)




...{


if(!(*st))


return (*st)->data;


else


return NULL;


}