数据结构与算法分析

1.描述：实质是一种受到限制的表，即插入删除只能在表的末端，能够实现LIFO（后进先出）

2.栈的实现

　　链表实现（链栈）

　　数组实现（顺序栈）

3.链栈

创建一个空栈

struct Node 
{
    int value;
    Node *next;
};

//创建了一个头节点为S的链栈,S将一直表示栈顶元素
Node *CreatStack()
{
    Node *S = new Node;
    S->next = NULL;
    return S;
}

测试栈是否为空

int IsEmpty(Node *S)
{
    return S->next == NULL;
}

从栈顶弹出元素

void Pop(Node *S)
{
    Node *FirstCell;
    if (IsEmpty(S))　　　　　　　　　　　　　　　　  //空栈，将返回异常
        cout << "Empty Stack" << endl;
    else
    {
        FirstCell = S->next; 　　　　　　　　　　　//取出栈顶
        S->next = S->next->next;　　　　　　　　  //使S指向新的栈顶
        delete FirstCell;　　　　　　　　　　　　  //删除原栈顶，完成出栈
    }
}

返回栈顶元素（不弹出，不改变栈顶指针），遇到空栈将返回异常

int Top(Node *S)
{
    if (!IsEmpty(S))
        return S->next->value;
5 ｝

清空栈（同时销毁物理内存）

void MakeEmpty(Node *S)
{
    while (!IsEmpty(S))
        Pop(S);
}

压栈

void Push(int x, Node *S)
{
    Node *TempCell = new Node;
    if (TempCell == NULL)
        cout << "Out of space" << endl;
    else
    {
        TempCell->value = x;　　　　　　　　　　//把x赋值给value
        TempCell->next = S->next;　　　　　　  //将新节点设为栈顶
        S->next = TempCell;　　　　　　　　　　 //使S指向新的栈顶
    }
}

遍历栈

void Print(Node *S)
{
    Node *p = S->next;　　　　　　　　//将p初始化为栈顶
    while (p != NULL)
    {
        cout << p->value << endl;
        p = p->next;
    }
}

注意，内存分配操作的时间开销较大（C的malloc和free，C++的new和delete），可用通过建立第二个栈来避免，第一个栈中的元素弹出时将不会被删除，而是暂时存放在第二个栈中，然后当第一个栈需要新的元素时，将首先在第二个栈中查找，由于在链栈中，所有的操作均花费常数时间，所以检索第二个栈的开销相对于内存分配是值得的。

声明一个Stack链表

struct Stack 
{
    Node *top;　　　　　　　　//top指向栈顶
    Node *bottom;　　　　　　//bottom指向栈底
};

这样在任意Node处都可以通过p->top或者p->bottom的方式获得当前栈的栈顶和栈底

判断栈是否为空也可以这样进行 

int IsEmpty(Node *p)
{
    if (p->top == p->bottom) 　　　　//栈顶和栈底相同
        return 1;
    else
        return 0;
}

4.顺序栈

用数组实现的顺序栈避免了使用指针，顺序栈使用一个一维数组来存放栈的元素

每一个栈有一个TopOfStack，对于空栈来说TopOfStack = -1

压栈时，将TopOfStack加1，Stack[TopOfStack] = x；出栈时，减1

typedef struct StackRecord 
{
    int capacity;　　　　//栈大小
    int TopOfStack;     //栈顶
    int *Array;         //数组地址
}Stack;

对空栈的pop和满栈的push都将引起程序崩溃

创建栈，数组实现

 创建空栈

void MakeEmpty(Stack *S)
{
    S->TopOfStack = -1;
}

创建栈（不考虑内存申请失败）

Stack* CreatStack(int MaxSize)
{
    StackRecord *S = new StackRecord;
    S->Array = new int[MaxSize];
    S->capacity = MaxSize;
    MakeEmpty(S);
    return S;
}

 检测是否为空栈

int IsEmpty(Stack *S)
{
    return S->TopOfStack == -1;
}

检测是否为满栈

int IsFull(Stack *S)
{
    return S->TopOfStack == MaxSize - 1;
}

进栈

void Push(int x, Stack *S)
{
    if (IsFull(S))　　　　　　　　　　　　　　//栈满将抛出异常
        ;
    else
        S->Array[++S->TopOfStack] = x;
7　　　//S->TopOfStack++;
8     //S->Array[TopOfStack] = x;
9 }

返回栈顶元素

int Top(Stack *S)
{
    if (!IsEmpty(S))
        return S->Array[S->TopOfStack];
    else
        ;
}

出栈

void Pop(Stack *S)
{
    if (IsEmpty(S))
        ;
    else
        S->TopOfStack--;
}

栈的遍历

以遍历数组的方式遍历即可

释放栈

void DisposeStack(Stack *S)
{
    if (S != NULL)
    {
        delete S->Array;
        delete S;
    }
}

5.链栈与顺序栈

顺序栈比链栈操作简便，避免了指针，但对存储空间利用效率低，大小固定，不如链表实现灵活

数组实现时，声明的栈太小，会造成栈溢出，太大则造成空间浪费

6.栈的应用

数据结构应用 - 栈

参考资料：《数据结构与算法分析——C语言描述》    Mark Allen Weiss