数据结构P2.1:栈

栈的基本概念

• 栈(stack)的定义：只允许在一端进行插入或者删除操作的线性表
• 栈的特点：后进先出

栈顶(top)：允许插入和删除的一端
栈底(bottom)：不允许插入和删除的一端
空栈：不含任何数据元素的栈称为空栈

• 逻辑结构：和普通线性表一样，元素之间是有位序的，插入和删除不同
• 栈的基本操作–创销、增删改查：

初始化栈：构建一个空栈S，分配内存空间
销毁操作：销毁栈并释放栈S所占的内存空间

插入(Push)操作：进栈，若栈S未满，则将要插入的元素x加入其中使之成为栈顶
删除(Pop)操作：出栈，若栈S非空，则弹出栈顶元素

查找(GetPop)：读栈顶元素

顺序栈的实现（顺序存储结构）

• 栈的本质是一个线性表，线性表有两种存储形式，栈也分为栈的顺序存储结构和栈的链式存储结构
• 顺序栈缺点：栈的大小不可改变

顺序栈的初始化

typedef struct {
    
    ElemType data[MAXSIZE];     /*静态数组存放栈中元素*/
    int top;                    /*栈顶指针，用于标注栈顶的位置（数组下标） */
}SqStack;

//初始化栈
void InitStack(SqStack &S){
    S.top = -1;                 /*初始化栈顶指针，因为此时为空栈，所以为-1*/
}

//判断是否栈空
bool EmptyStack(SqStack S){
    if(S.top==-1)
        return true;            /*栈空*/
    else
        return false;           /*栈非空*/
}

void testStack(){
    SqStack S;                  /*声明一个顺序栈结构体S，为其分配内存空间*/
    InitStack (S);
}

进栈操作

//插入，新元素入栈
bool Push(SqStack &S, ElemType x){
    if(S.top==MAXSIZE-1)        /*栈满，S.top数组位序为9，报错*/
        return false;
    S.top=S.top+1;              //指针先+1，为新的栈顶
    S.data[S.top]=x;            //新元素入栈
    return true;
}

出栈操作

//删除栈顶元素
bool Pop(SqStack &S,ElemType &x){
    if(S.top==-1)               /*栈空，报错*/
        return false;
    x=S.data[S.top];            /*栈顶元素先出栈*/
    S.top=S.top-1;              //指针-1，为新的栈顶
    return true;
}  

读取栈顶元素

//栈顶元素读取操作
bool GetStack(SqStack S,ElemType x){
    if(S.top==-1)               /*栈空，报错*/
        return false;
    x=S.data[S.top]; 
    return true;
}

链栈的实现（链式存储结构）

• 链栈：栈的链式存储结构
• 链栈优点：方便扩建
• 链栈缺点：不可随机读取

链栈的初始化

//链栈的定义
//由单链表的各个结点的结构体定义和链表组成
//链栈的定义
typedef struct StackNode{
    ElemType data；                             /*数据域栈中元素*/
    struct StackNode *next;                     /*指针域，指向链栈的下个结点*/
}StackNode;

typedef struct{                                /*链式队列的定义*/
    StackNode *top;                             /*栈的栈顶指针*/
}LinkStack;

/*栈类型定义*/
//带头结点链栈的初始化
bool InitLinkStack(LinkStack &S){
    StackNode *L=(StackNode*)malloc(sizeof(StackNode));      /*给头结点分配空间*/
    if(L==NULL)                                              /*内存不足，分配失败*/
        return false;
    L->next = NULL;
    S.top=L;                                                /*初始化时头结点为栈顶*/
}

//判断是否栈空
bool Empty(LinkStack S){
    if(S.top==NULL)
        return true;
    else
        return false;
}

void testLinkStack(){
    LinkStack S;
    InitLinkStack(S); 
}

链栈的插入

//进栈操作：头结点的后插
//链头即为栈顶
bool EnStack(LinkStack &S, ElemType e){
    if (S.top==NULL)
        return false;
    StackNode *n=(StackNode*)malloc(sizeof(StackNode));   /*给新的链栈结点(栈顶结点)分配空间*/
    if (n==NULL)                                          /*内存不足，分配失败*/
        return false;
    n->data = e;
    n->next = S.top;                                      /*结点n插入到了头结点后面，为新的链栈栈顶*/
    S.top = n;                                            /*修改栈顶指针top指向结点n*/
    return true;
}

链栈的删除

//出栈操作：头结点的后删
bool DelStack(LinkStack &S,ElemType &e){
    if (S.top==NULL)                                        /*空栈，报错*/
        return false;
    StackNode *p=S.top;                                     /*S的后继结点为栈顶结点top,要删除这个结点*/
    e = p->data;                                            /*变量e返回当前结点p（当前队头）数据*/
    if(p->next!=NULL)                                       /*栈顶不是最后一个元素*/            
        S.top = p>next;                                     /*修改当前S的栈顶top指针为p结点的下一个结点*/
    free(p);                                                /*删除栈顶结点，并释放栈顶空间*/
    return true;
}