学习 栈 总结

学习 栈 总结

栈只限定在表尾进行插入和删除操作的线性表.

栈的插入操作，叫做入栈. 栈的删除操作叫做出栈. 大致如下图所示：

栈的抽象数据类型

Data
    同线性表，元素具有相同的类型，相邻元素有前驱和后继关系.
Operation
    InitStack(*S);
    DestroyStack(*S);
    ClearStack(*S);
    StackEmpty(*S);
    GetTop(S, *e);
    Push(*S, e);
    Pop(*S, *e);
    StackLength(S);

顺序栈

顺序栈的三种情况如下图所示：

顺序栈结构定义如下：

#define MAXSIZE 20
typedef int SElemType;
// 顺序栈定义
typedef struct
{
    SElemType data[MAXSIZE];
    int top;
}SqStack;

顺序栈初始化

int InitStack(SqStack* Stack)
{
    Stack->top = -1;
    return OK;
}

进栈操作

int Push(SqStack* Stack, SElemType Element)
{
    if (Stack->top == MAXSIZE - 1)
    {
        return ERROR;
    }

    Stack->top++;
    Stack->data[Stack->top] = Element;

    return OK;
} 

出栈操作

int Pop(SqStack* Stack, SElemType* ELement)
{
    if (-1 == Stack->top)
    {
        return ERROR;
    }

    *Element = Stack->data[Stack->top];
    Stack->top--;

    return Ok;
}

获取栈顶元素

int GetTop(SqStack Stack, SElemType* Element)
{
    if (-1 == Stack->top)
    {
        return ERROR;
    }
    else
    {
        *Element = Stack.data[Stack.top];
        return OK;
    }
}

链式栈

链栈结构图如下：

链栈结构定义

typedef int SElemType;
// 链栈结点定义
typedef struct StackNode
{
    SElemType data;
    struct StackNode* next;
}StackNode, *LinkStackPtr;

typedef struct
{
    LinkStackPtr top;
    int count; // 记录栈中元素个数
}LinkStack;

链栈的初始化

int InitStack(LinkStack* Stack)
{
    Stack->top = (LinkStackPtr)malloc(sizeof(StackNode));
    if (NULL == Stack->top)
    {
        // exit;
    }

    Stack->top = NULL;
    Stack->count = 0;

    return Ok;
}

进栈操作

进栈过程如下图所示：

int Push(LinkStack* Stack, SElemType Element)
{
    LinkStackPtr CurrentNode = (LinkStackPtr)malloc(sizeof(StackNOde));
    if(NULL == CurrentNode)
    {
        // exit;
    }

    CurrentNode->data = Element;
    CurrentNode->next = Stack->top;
    Stack->top = CurrentNode;

    Stack->count++;

    return OK;
}

链栈判空

int StackEmpty(LinkStack Stack)
{
    if (0 == Stack.count)
        return TRUE;
    else
        return FALSE;
}

链栈置空

int ClearStack(LinkStack* Stack)
{
    LinkStackPtr NewNode, OldNode;
    NewNode = Stack->top;

    while(NewNode)
    {
        OldNode = NewNode;
        NewNode = NewNode->next;
        free(OldNode);
    }

    Stack->count = 0;
    return Ok;
}

出栈操作

出栈操作过程如下：

int Pop(LinkStack* Stack, SElemType* Element)
{
    LinkStackPtr CurrentNode;

    if (StackEmpty(*Stack))
        return ERROR;

    *Element = Stack->top->data;
    CurrentNode = Stack->top;
    Stack->top = Stack->top->next;

    free(CurrentNode);
    Stack->count--;
    return Ok;
}   

参考文档

http://www.nowamagic.net/librarys/veda/detail/2293