Sequential storage and chain storage of stack implementation

   The sequential storage structure of the stack consists of a one-dimensional array and a variable that records the position of the elements at the top of the stack ,
    In addition, a variable can be used to store the maximum capacity of the stack Maxsize

/**
     The sequential storage structure of the stack consists of a one-dimensional array and a variable that records the position of the elements at the top of the stack ,
     In addition, a variable can be used to store the maximum capacity of the stack Maxsize
*/

/**
#include <iostream>
#include <cstdio>
#include <cstdlib>
using namespace std;

#define error -1
const int Maxsize = 100;
typedef int ElementType;
typedef int Position;
typedef struct SNode * PtrToSNode;
struct SNode
{
    ElementType *Data;
    Position Top;
    int Maxsize;
};
typedef PtrToSNode Stack;
Stack CreateStack(int Maxsize);
bool IsFull(Stack S);
bool Push(Stack S,ElementType X);
bool IsEmpty(Stack S);
ElementType Pop(Stack S);
int main()
{
    Stack S=CreateStack(Maxsize);
    for(int i=1;i<50000000;i+=i)
        Push(S,i);
    for(int i=0,T=S->Top;i<=T+5;++i)
    {
        auto tem=Pop(S);
        if(tem!=error)
            printf("%d ",tem);
    }
    return 0;
}

Stack CreateStack(int Maxsize)
{
    Stack S=(Stack) malloc(sizeof(SNode));
    S->Data=(ElementType *) malloc(Maxsize * sizeof(ElementType));
    S->Top=-1;
    S->Maxsize=Maxsize;
    return S;
}

bool IsFull(Stack S)
{
    return (S->Top==S->Maxsize-1);
}

bool Push(Stack S,ElementType X)
{
    if(IsFull(S))
    {
        printf(" The stack is full \n");
        return false;
    }
    else
    {
        S->Data[++(S->Top)]=X;
        return true;
    }
}

bool IsEmpty(Stack S)
{
    return (S->Top==-1);
}

ElementType Pop(Stack S)
{
    if(IsEmpty(S))
    {
        printf(" Stack empty \n");
        return error;
    }
    else
    {
        return (S->Data[(S->Top)--]);
    }
}
*/

  The chain storage implementation of stack ：

/**
     The chain storage implementation of stack ：
*/


#include <iostream>
#include <cstdio>
#include <cstdlib>
using namespace std;

#define error NULL
typedef int ElementType;
const ElementType inf=1e9;
typedef struct SNode * PtrToLNode;
//   The position here is the integer subscript of the array , from 0 Start , The bit order mentioned above refers to the number , from 1 Start 
struct SNode
{
    ElementType data;
    PtrToLNode next;
};
typedef PtrToLNode Position;
typedef PtrToLNode Stack;

Stack CreateStack();
bool IsFull(Stack S);
bool Push(Stack S,ElementType X);
bool IsEmpty(Stack S);
ElementType Pop(Stack S);

int main()
{
    Stack S=CreateStack();
    for(int i=1;i<50000000;i+=i)
        Push(S,i);
    while(!IsEmpty(S))
    {
        auto tem=Pop(S);
        if(tem!=inf)
            printf("%d ",tem);
    }
    return 0;
}

// Stack of leading nodes 
Stack CreateStack()
{
    Stack S;
    S=(Stack) malloc(sizeof(SNode));
    S->next=NULL;
    return S;
}

bool Push(Stack S,ElementType X)
{
    Position Temcell;
    Temcell=(PtrToLNode) malloc(sizeof(SNode));
    Temcell->data=X;
    Temcell->next=S->next;
    S->next=Temcell;
    return true;
}

bool IsEmpty(Stack S)
{
    return (S->next==NULL);
}

ElementType Pop(Stack S)
{
    Position FirstCell;
    ElementType TopElem;
    if(IsEmpty(S))
    {
        printf(" Stack empty \n");
        return inf;
    }
    else
    {
        FirstCell=S->next;
        TopElem=FirstCell->data;
        S->next=FirstCell->next;
        free(FirstCell);
        return TopElem;
    }
}