自定义Stack

某些情况下，不能使用STL，那么就需要自定义栈，实现如下：

1.模板方法实现方式

栈的主要实体是一个单链表，每次入栈把结点插入表头，每次出栈删除表头结点

/*
 *	自定义栈
 */
template<class T>
struct Stack {
    T node;
    Stack* next;
};


template<class T>
void initStack(Stack<T> **s) {
    *s = new Stack<T>();
    (*s)->next = NULL;
}

template<class T>
void push(Stack<T> *s, T t) {
    Stack<T> *n = new Stack<T>();
    n->node = t;
    n->next = s->next;
    s->next = n;
}

template<class T>
T pop(Stack<T> *s) {
    if (s->next != NULL) {
        Stack<T> *t = s->next;
        s->next = t->next;
        T ret = t->node;
        delete t;
        return ret;
    }
    return NULL;
}

template<class T>
bool empty(Stack<T> *s) {
    if (s->next != NULL) {
        return false;
    }
    return true;
}

2.模板类实现方式

栈的实体是一个预先分配好的数组，入栈是往数组里加入元素，index后移；出栈是取出index位置元素，index前移。另外由于是预先分配大小，出现不够用的情况，则自动增加一倍大小size。

template<class T>
class Stack {
public:
    Stack(){
        data = new T[1];
        capacity = 1;
        top = -1;
    }
    void push(T t) {
        if (top+1 == capacity) {
            capacity *= 2;
            T* n = new T[capacity];
            if (n == NULL) {
                return;
            }
            for(int i=0; i<=top; ++i) {
                n[i] = data[i];
            }
            data = n;
        }
        data[++top] = t;
    }
    T pop() {
        T ret = data[top];
        --top;
        return ret;
    }
    bool empty() {
        if (top == -1) {
            return true;
        }
        return false;
    }
public:
    T* data;
    int top;
    int capacity;
};