链式栈

2016年7月23日15:39:13
    为什么需要链式栈?
        这是因为,顺序栈的使用需要事先指定存贮空间的大小,如果静态分配的存贮空间分配的过大,使得内存空间浪费,
        而事先指定的存贮空间分配的过小,会使得,在程序运行时可能会发生存贮空间不够的情形,这就产生了栈的链式
        存贮结构.
    什么时候适合使用链式栈?
        当数据元素的数目变化较大时,或者数据元素的数目事先不确定时,适合使用栈的链式存贮结构;
    什么是链式栈?
        栈的链式存贮结构是用一组不连续的存贮空间来存放栈中的数据元素的存贮结构;
    链式栈为什么一般不用定义头结点?
        栈是一种操作受限的线性表,这是因为栈本身是一种线性表,但是只能在表头进行插入和删除操作,
        那么链式栈就是只能在链表的头部进行插入和删除操作,那么既然就已经确定操作的位置了,就不在
        需要头结点了,在链表中定义头结点的目的是:定义头结点是为了方便和统一链表插入和删除的操作,使得第一个
        节点的插入和删除操作和中间节点的插入和删除操作统一.
    链式栈的栈顶指针如何表示?
        链表的必须参数是头指针,而栈的必须参数是栈顶指针,于是我们可以把链表的头指针当做栈的栈顶指针来使用.

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
typedef int DataType;

//链表结点的结构体类型定义
typedef struct node  
{
    DataType stack;//数据域
    struct node * pNext;//指针域
}linkList;

//链式栈的结构体类型定义
typedef struct stack
{
    linkList * pTop;//指向栈顶元素
    linkList * pBottom;//指向栈底元素
}linkStack;

//函数前置声明
void initLinkStick(linkStack * S);//初始化链式栈
int  isEmpty(linkStack * S);//判断链式栈是否为空
int  pushLinkStick(linkStack * S,DataType element);//链式栈的压栈操作
int  popLinkStick(linkStack * S,DataType * element);//链式栈弹栈操作
int  getTop(linkStack * S, DataType * element);//获取链式栈的栈顶元素
int  getLength(linkStack * S);//获取链式栈的长度
void destroyLinkStick(linkStack * S);//链式栈的销毁

//链式栈的初始化
void initLinkStick(linkStack * S)
{
    S->pTop = (linkList * )malloc(sizeof(linkList));
    if(!S->pTop)
    {
        printf("动态内存分配失败!\n");
        exit(-1);
    }
    S->pBottom = S->pTop;
    S->pBottom->pNext = NULL;
    return ;
}

//判断链式栈是否为空,若为空则返回1,不为空则返回0;
int  isEmpty(linkStack * S)
{
    if(S->pBottom == S->pTop)
        return 1;
    else
        return 0;
}

//链式栈的压栈操作
int  pushLinkStick(linkStack * S,DataType element)
{
    linkList * pNew;

    pNew = (linkList * )malloc(sizeof(linkList));
    if(NULL == pNew )
    {
        printf("动态内存分配失败!\n");
        exit(-1);
    }
    pNew->stack = element;
    /*if( NULL == pTop )
    {
        pNew->pNext = NULL;
        pTop = pNew;
    }
    else
    {
        pNew->pNext = pTop;
        pTop = pNew;
    }*/
    pNew->pNext = S->pTop;
    S->pTop = pNew;
    return 1;
}

//链式栈的弹栈操作
int  popLinkStick(linkStack * S,DataType * element)
{
    linkList * pFree;

    if( isEmpty(S) )
    {
        printf("栈为空,无法继续出栈");
        return 0;
    }

    pFree = S->pTop;
    *element = pFree->stack;
    S->pTop = S->pTop->pNext;
    free(pFree);
    return 1;
}

//获取链式栈的栈顶元素
int  getTop(linkStack * S, DataType * element)
{
    if(isEmpty(S))
        return 0;
    *element = S->pTop->stack;
    return 1;
}

//获取链式栈的长度
int  getLength(linkStack * S)
{
    int i = 0;
    linkList * pCur;
    pCur = S->pTop;
    /*
    if(NULL == pCur)
    {
        printf("栈为空!\n");
        return 0;
    }
    */
    while( pCur )
    {
        pCur = pCur->pNext;
        i++;
    }
    return i;
}

//链式栈的销毁
void destroyLinkStick(linkStack * S)
{
    while(S->pTop)
    {
        S->pBottom = S->pTop->pNext;
        free(S->pTop);
        S->pTop = S->pBottom;
    }
    return;
}

//主函数
int main(void)
{
    linkStack S;
    DataType  element;
    initLinkStick(&S);
    return 0;
}