(C/C++)数据结构二：栈、队列的基本操作

InitStack 初始化操作

DestroyStack 销毁栈操作

StackEmpty 判断是否为空栈

StackLength 求栈的长度

GetTop 取栈顶元素

ClearStack 栈置空操作

Push 入栈操作

Pop 出栈操作

栈的表示和基本操作：

#define MAXSIZE 100
typedef struct {
    SElemType *base;//栈底指针
    SElemType *top; //栈顶指针
    int stacksize; //栈最大容量
}SqStack;
//顺序栈的初始化

Status InitStack(SqStack &s)
{
    s.base = new SElemType[MAXSIZE];
//或s.base = (SElemType*)malloc(MAXSIZE*sizeof(SElemType));
    if(!s.base)exit(OVERFLOW)//存储分配失败
    s.top = s.base;//栈顶指针等于栈底指针
    stacksize = MAXSIZE;
    return OK;
}
//判断顺序栈是否为空
//base 指针和top指针是否相同
Status StackEmpty(SqStack s)
{
//若栈为空，返回TRUE，否则返回FALSE
    if(s.top==s.base)
        return TRUE;
    else
        return FALSE;
}

//求顺序栈长度
int StackLength(SqStack s)
{
    return s.top-s.base;
}
//清空顺序栈
int StackClear(SqStack &s)
{
    if(s.base)s.top = s.base;//判断栈不空
    return OK;
}
//销毁顺序栈
int DestroyStack(SqStack &s)
{
    if(s.base){
        delete s.base;
        s.stacksize = 0;
        s.base = s.top = NULL;
    }    
    return OK;
}
//入栈
Status Push(SqStack &s,SElemType e)
{
    if(s.top - base == s.stacksize)//栈满
        return ERROR;
    *s.top++ = e;
    return OK;
}
//出栈
Status Pop(SqStack &s,SElemType &e)
{
    if(s.top == s.base)
        return ERROR;   
    s.top--;
    e = *s.top
}
//链栈的表示和实现
//链栈是单链表，只能在链表头部操作

type struct StackNode{
    SElemType data;
    struct StakNode *next;
}StackNode,*LinkStack;
LinkStack s;
/*链表的头指针就是栈顶，不需要头结点，插入和删除仅在栈顶处执行*/

//链栈的初始化
void InitStack(LinkStack &s)
{
    s = NULL;
}
//判断链栈是否为空
Status StackEmpty(LinkStack s)
{
    if(s==NULL)return TRUE;
    else return FALSE;
}

//链栈的入栈
Status Push(LinkStack &s,SElemType e)
{
    p = new StackNode;//生成新结点p
    p->data = e;// 将新结点数据域置为e;
    p->next = s;//将新结点插入栈顶
    s = p;//修改栈顶指针
    return OK;
}
//链表的出栈
Status Pop(LinkStack &s,SElemType &e)
{
    if(s==NULL)return ERROR;
    e = s->data;
    p = s;
    s = s->next;
    delete p;
    return OK;
}

//取栈顶元素
SElemType GetTop(LinkStack s)
{
    if(s!=NULL)
        return s->data;
}

队列的表示和操作：

只能在表的一端插入，另一端删除（头删尾插）

存储结构：顺序队、链队

/*循环队列的顺序表示*/
#define MAXQSIZE 100//最大队列长度

Typedef struct{
    QElemType*base;//初始化动态分配存储空间
    int front;//头下标
    int rear;//尾指针
}SqQueue;
//初始化
Status InitQueue(SqQueue &Q)
{
    Q.base = new QElemType[MAXQSIZE]//分配数组空间
    if(!Q.base)exit(OVERFLOW)//存储分配失败    
    Q.front = Q.rear = 0;
    
}
//求队列长度
int QueueLength(SqQueue Q)
{
    return ((Q.rear-Q.front+MAXQSIZE)%MAXQSIZE);
}
//入队
Status EnQueue(SqQueue &Q,QElemType e)
{
    if((Q.rear+1)%MAXQSIZE == Q.front)return ERROR;//队满
    Q.base[Q.rear] = e;//新元素加入队尾
    Q.rear=(Q.rear+1)%MAXQSIZE;//队尾指针+1，循环
    return OK;
}
//出队
Status DeQueue(SqQueue &Q,QElemType &e)
{
    if(Q.front == Q.rear)return ERROR;//队空
    e = Q.base[Q.front];//保存队头元素
    Q.front = (Q.front+1)%MAXQSIZE;//队头指针+1，循环
    return OK;
}
//取队头元素
SElemType GetHead(SqQueue Q)
{
    if(Q.front!=Q.rear)//队列不空
        return Q.base[Q.front];//返回队头指针元素，队头指针不变
}





/*链队*/
#define MAXQSIZE 100//队列最大长度
typedef struct Qnode{
    QElemType data;
    struct Qnode *next;
}QNode,*QuenePtr;

typedef struct{
    QuenePtr front;//队头指针
    QuenePtr rear;//队尾指针
} LinkQueue;

//初始化
Status InitQueue (LinkQueue &Q)
{
    Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
    Q.front->next = NULL;
    return OK;
}
//销毁
Status DestroyQueue(LinkQueue &Q)
{
    while(Q.front){
        p = Q.front ->next;
        free(Q.front);
        Q.front = p;
    }
    return OK;    
}
//入队
Status EnQueue(LinkQueue &Q,QElemType e)
{
    p = (QueuePtr)malloc(sizeof(QNode));
    if(!p)exit(OVERFLOW);
    p->data = e;
    p->next = NULL;
    Q.rear->next = p;
    Q.rear = p; 
    return OK;
}

//出队
Status DeQueue(LinkQueue &Q,QElemType &e)
{
    if(Q.front==Q.rear)return ERROR;
    p = (QueuePtr)malloc(sizeof(QNode));
    if(!p)exit(OVERFLOW);
    p = Q.front->next;
    e = p->data;
    Q.front->next = Q.front->next->next;
    if(Q.rear==p)Q.rear = Q.front;//如果删除的是尾结点，要把尾结点指向头结点
    free(p);
    return OK;  
}
//求队头元素
Status GetHead (LinkQueue Q,QElemType &e)
{
    if(Q.front==Q.rear)return ERROR;
    e = Q.front ->next->data;
    return OK;
}