栈的学习笔记（链栈的基本操作：带头结点和不带头结点）

//顺序栈的定义
#define MaxSize 10//定义栈中元素的最大个数
typedef struct{
ElemType data[MaxSize];//静态数组存放栈中的元素 
int top; //栈顶指针 
}SqStack;

//初始化栈
void InitStack(SqStack &S)
{
    S.top=-1;//初始化栈顶指针 
 } 
 // 判断栈空
bool StackEmpty(SqStack S)
{
    return (S.top==-1);
 } 
 
void testStack(){
    SqStack S;//声明一个顺序栈(分配空间)
    InitStack(S);//初始化 
} 

//新元素入栈
bool Push(SqStack &S,ElemType x){
    if(S.top==MaxSize-1)//栈满，报错 
    {
        return false;
    }
    S.top=S.top+1;//指针先加1 
    S.data[S.top]=x; //新元素入栈 
    return true; 
} 
//简化版 
bool Push(SqStack &S,ElemType x){
    if(S.top==MaxSize-1)//栈满，报错 
    {
        return false;
    }
    S.data[++S.top]=x; 
    //指针先加1 
     //新元素入栈 
    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
    //上面两行可简化为  x=S.data[S.top--]; 
    return 0; 
 } 
//读栈顶元素
bool GetTop(SqStack &S,ElemType &x)
{
    if(S.top==-1)//栈空，报错 
    {
        return false; 
    }
    x=S.data[S.top];
    return 0;
} 

//顺序栈的另一种实现方式 
#define MaxSize 10
typedef struct{
    ElemType data[MaxSize];
    int top; 
}SqStack;

//初始化栈
void InitStack(SqStack &S)
{
    S.top=0;//初始化栈顶指针 ,实际上是让top指针指向了下一个可插入元素的位置 
 } 
 
void testStack()
{
    SqStack S;//声明一个顺序栈（分配空间）
    InitStack(S);//初始化 
 } 
//判空
bool EmptyStack(SqStack S)
{
    return (S.top==0);
 } 
//新元素入栈
bool Push(SqStack &S,ElemType x)
{
    if(S.top==MaxSize)//栈满，报错 
    {
        return false;
    }
    S.data[S.top]=x;
    S.top=S.top+1;
    //S.data[S.Top++]=x; 
 } 

//链栈（推荐使用不带头结点的链表存储） 
//链栈的定义 
typedef struct LinkNode{
    int data;//数据域 
    struct LinkNode *next;//指针域 
}LinkNode,*LiStack; //栈类型定义

//带头结点的初始化 
bool InitStack(LiStack &S)
{
    S=(LinkNode*)malloc(sizeof(LinkNode));
    if(S!=NULL){
        S->next=NULL;
    }
    return true;
 } 
//不带头结点的初始化
bool InitStack(LiStack &S)
{
    S=NULL;
    return true;
}
//判空(带头结点)
bool StackEmpty(LiStack S)
{
    return (S->next==NULL);
 } 
//判空(不带头结点)
bool StackEmpty(LiStack S)
{
    return (S==NULL);
 } 
void testStack()
{
    LiStack S;
    InitStack(S);
    
}
//进栈（增）(带头结点) 栈先进后出/后进先出 只能在顶部插入类似于单链表的头插法 
bool Push(LiStack &S,int x)
{
    LinkNode* p=(LinkNode*)malloc(sizeof(LinkNode));
    if(p==NULL)
    {
        return false;
    }
    p->data=x;
    p->next=S->next;
    S->next=p;
    return true; 
}
//进栈（增）(不带头结点)
bool Push(LiStack &S,int x){
    LinkNode* p=(LinkNode*)malloc(sizeof(LinkNode));
    if(p==NULL)
    {
        return false;
    }
    p->data=x;
    if(S==NULL)
    {
        S=p;
     } 
     if(S!=NULL)
     {
         p->next=S;
         S=p;
     }
     return true;
}
//出栈（删）(带头结点)  相当于删除头结点的下一个结点 
bool Pop(LiStack &S,int &x)
{
    if(S->next==NULL)//空栈，不能出栈 
    {
        return false;
    }
    LinkList* p;
    x=p->data;
    p=S->next;
    S->next=p->next;
    free(p);
    return true; 
 } 
//出栈（删）(不带头结点) 相当于删除单链表的第一个结点 
bool Pop(LiStack &S,int &x)
{
    if(S==NULL)//空栈，不能出栈 
    {
        return false;
    }
    LinkNode* p=S;
    x=p->data;
    S=p->next;
    free(p);
    return true;     
 } 
//查（获取栈顶元素）(带头结点)
LinkNode* GetElem(LiStack S)
{
    if(S.next!=NULL)
    {
        return S->next->data;
     } 
 } 
//查（获取栈顶元素）(不带头结点)
LinkNode* GetElem(LiStack S)
{
    if(S!=NULL)
    {
        return S->data;
    }
 } 
//求栈长(带头结点)
int Length(LiStack S)
{
    int  len=0;
    LinkNode* p;
    p=S; 
    while(p->next!=NULL)
    {
        p=p->next;
        len++;
    }
    return len+1;
 } 
 //求栈长(不带头结点)
 int Length(LiStack S)
 {
     int len=0;
     LinkNode* p=S;
     while(p!=NULL)
     {
         p=p->next;
         len++;
     }
     return len+1;
  }