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

本文使用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;
}