顺序栈的实现

#define MaxSize 50;
typedef struct{
    ElemType data[MaxSize];
    int top
}sqstack
//初始化
void initstack(sqstack &s){
    s.top = -1;
}
//判断栈空
bool stackempty(sqstack s){
    if(s.top == -1)
        return true;
    else 
        return false;
}
//入栈
bool push(sqstack & s,ElemType x){
    if(s.top == MaxSize - 1)
        return false;
    s.data[++s.top] = x;
        return true;
}
//出栈
bool pop(sqstack &s,ElemType &x){
    if(s.top == -1)
        return false;
    x = s.data[top--];
        return true;
}
//读栈顶元素
bool gettop(sqstack,Elemtype &x){
    if(s.top == -1)
        return false;
    x = s.data[top];
        return true;
}

链栈的实现(不带头结点)

#define MaxSize 50;
typedef struct SNode{
    ElemType data;
    struct SNode *next;
}SNode,*linkstack;
//初始化
bool initstack(linkstack &s){
    s = (SNode *)malloc(sizeof(SNode));
    s->next = NULL;
    return true;
}
//判断栈空
bool stackempty(linkstack s){
    if(s->next == NULL)
        return true;
    else 
        return false;
}
//入栈(头插法)
bool push(linkstack &s,ElemType x){
    SNode *p = (SNode *)malloc(sizeof(SNode));
    s.data = x;
    p->next = s->next;
    s->next = p;
    return true;
}
//出栈(头删法)
bool pop(linkstack &s,ElemType &x){
    if(s->next == NULL)
        return false;
    SNode *p = s->next;
    x = p->data;
    s->next = p->next;
    free(p);
    return true;
}

定义链式存储的栈(双链表实现)

//定义双链表结点类型
typedef struct DbSNode{
    ElemType data;
    struct DbSNode *last,*next;
}DbSNode;
//双链表实现的栈(栈顶在链尾)
typedef struct DbLiStack{
    struct DbSNode *head,*rear;
}DbLiStack,*Dbstack;
//初始化
bool initDbstack(Dbstack &s){
    s = (DbLiStack *)malloc(sizeof(DbLiStack));
    DbSNode *p = (DbSNode *)malloc(sizeof(DbSNode));
    p->next = NULL;
    P->last = NULL;
    s->head = P;
    s->rear = p;
    return true;
}
//判空
bool StackEmpty(Dbstack s){
    if(s->head == s->rear)
        return true;
    else 
        return false;
}
//入栈(在双链表链尾插入)
bool push(Dbstack &s,ElemType x){
    DbSNode *p = (DbSNode *)malloc(sizeof(DbSNode));
    p->data = x;
    p->last = s->rear;
    s->rear->next = p;
    s->rear = p;
    return true;
}
//出栈
bool pop(Dbstack &s,ElemType &x){
    if(s->head == s->rear)
        return false;
    DbSNode *p = s->rear;
    x = p->data;
    s->rear = p->last;
    s->rear->next = NULL;
    free(p);
    return true;
}

队列的顺序存储(循环队列)

#define MaxSize 50;
typedef struct{
    ElemType data[MaxSize];
    int front,rear;
}SqQueue;
//初始化
void initQueue(SqQueue &q){
    q.front = q.rear = 0;
}
//判队空
bool isEmpty(SqQueue q){
    if(q.front == q.rear)
        return true;
    else 
        return false;
}
//入队
bool EnQueue(SqQueue &q,ElemType x){
    if(Q.rear + 1) % MaxSize == Q.front;
        return false;
    Q.data[Q.rear] = x;
    Q.rear = (Q.rear + 1) % MaxSize;
    return true;
}
//出队
bool DeQueue(SqQueue &q,ElemType &x) {
    if(q.rear == q.front)
        return false;
    x = q.data[q.front];
    q.front = (q.front + 1) % MaxSize;
    return true;
}

链式队列

//链式队列结点
typedef struct LinkNode{
    ElemType data;
    Struct LinkNode *next;
}LinkNode;
//链式队列
typedef struct{
    LinkNode *front,*rear;
}LinkQueue;
//初始化
void initQueue(LinkQueue &q){
    q.front = q.rear = (LinkNode *)malloc(sizeof(LinkNode));
    q.front->next = NULL;
}