栈

栈、队列、双端队列和列表都是有序的数据集合，其元素的顺序取决于添加顺序或移除顺序。一旦某个元素被添加进来，它与前后元素的相对位置保持不变。这样的数据集合经常被成为 线性数据结构。

基本概念

栈，又称堆栈（有时也称作下堆栈），它是一种运算受限的线性表，是有序集合，添加操作和移除操作总发生再同一端，即“顶端”，另一端被称为“底端”。

栈的特性：

• LIFO（last-in first out）：后进先出，最先添加的元素将被最后移出
• 反转特性：输入堆栈的数据时一种序列，输出堆栈的数据元素时另一种序列

栈的实现

用 Python 实现栈

Python 的列表是有序集合，它提供了一整套方法可以帮助我们实现栈。

以列表尾部作为栈的顶端：

class Stack:
    def __init__(self):
        self.items = []

    def isEmpty(self):
        return self.items == []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()
    
    def peek(self):
        return self.items[len(self.items)-1]

    def size(self):
        return len(self.items)

    def printStack(self):
        print(self.items)

以列表头部作为栈的顶端：

class Stack:
    def __init__(self):
        self.items = []

    def isEmpty(self):
        return self.items == []

    def push(self, item):
        self.items.insert(0, item)

    def pop(self):
        return self.items.pop(0)

    def peek(self):
        return self.items[0]

    def size(self):
        return len(self.items)

append 方法和 pop() 方法的时间复杂度都是 O(1)，所以不论栈中有多少个元素，第一种实现中的 push 操作和 pop 操作都会在恒定时间内完成。第二种实现的性能则受制于栈中的元素个数，因为 insert(0) 和 pop(0) 的时间复杂度都是 O(n)，元素越多就越慢。所以列表尾部作为栈的顶端实现栈性能更加优良。

用 C 实现栈

顺序存储的堆栈称为顺序堆栈：

#define MaxStackSize 100
typedef int DataType;

typedef struct SeqStack
{
    DataType items[MaxStackSize];
    int top;
}Stack;

void stackInit(Stack *s)
{
    s->top = 0;
}

int isEmpty(Stack s)
{
    if (s.top <= 0)
        return 1;
    else
        return 0;
}

int push(Stack *s, DataType item)
{
    if (s->top == MaxStackSize)
    {
        return 1;
    }
    else 
    {
        s->items[s->top] = item;
        s->top++;
        return 0;
    }
}

int pop(Stack *s, DataType *data)
{
    if (s->top <= 0)
    {
        return 1;
    }
    else
    {
        *data = s->items[s->top-1];
        s->top--;
        return 0;
    }
}

int peek(Stack s, DataType *data)
{
    if (s.top <= 0)
    {
        return 1;
    }
    else
    {
        *data = s.items[s.top-1];
        return 0;
    }
}

int size(Stack s)
{
    return s.top;
}

链式存储结构的堆栈称作链式堆栈：

#include <stdio.h>
#include <stdlib.h>

typedef int DataType;

typedef struct LSNode
{
    DataType data;
    struct LSNode *next;
}Node;

void stackInit(Node **head)
{
    *head = (Node *)malloc(sizeof(Node));
    (*head)->next = NULL;
}

int isEmpty(Node *head)
{
    if (head->next == NULL)
        return 1;
    else
        return 0;
}

void push(Node *head, DataType item)
{
    Node *p = NULL;
    p = (Node *)malloc(sizeof(Node));
    p->data = item;
    p->next = head->next;
    head->next = p;
}

int pop(Node *head, DataType *data)
{
    Node *p = head->next;
    if (NULL == p)
    {
        return 1;
    }
    
    head->next = p->next;
    *data = p->data;
    free(p);

    return 0;
}

int peek(Node *head, DataType *data)
{
    Node *p = head->next;
    if (NULL == p)
    {
        return 1;
    }

    *data = p->data;

    return 0;
}

void destroy(Node *head)
{
    Node *p = NULL;
    Node *p1 = NULL;
    
    p = head;
    while (NULL != p)
    {
        p1 = p;
        p = p->next;
        free(p1);
    }

    head = NULL;
}

对于链式堆栈，若把靠近头指针的一端定义为栈顶，则插入元素和删除元素时不需要遍历整个链表，其时间复杂度为 O(1)；否则，若把远离头指针的一端定义为栈顶，则每次插入和删除元素都需要遍历整个链，其实际复杂度为 O(n)。因此，通常链式堆栈都设计成把靠近头制作的一端定义为栈顶。