数据结构笔记（二） 栈和队列（C语言描述）

数据结构（二） 栈和队列

栈

顺序栈

存储结构

#define MAXSIZE 50
#define SElemType int
typedef struct{
    
    
    SElemType *top;
    SElemType *base;
    int stacksize;
}SqStack;

初始化

bool initStack(SqStack &S){
    
    
    S.base = new SElemType[MAXSIZE];
    if(!S.base){
    
    
        cout << "内存分配失败" << endl;
        return false;
    }
    S.top = S.base;
    S.stacksize = MAXSIZE;
    return true;
}

入栈

bool Push(SqStack &S, SElemType e){
    
    
    if(S.top - S.base == S.stacksize){
    
    
        cout << "栈满，入栈失败" << endl;
        return false;
    }
    *S.top++ = e;
    return true;
}

出栈

bool Pop(SqStack &S, SElemType &e){
    
    
    if(S.top == S.base){
    
    
        cout << "栈空，出栈失败" << endl;
        return false;
    }
    e = *--S.top;
    return true;
}

获取栈顶元素

SElemType getElem(SqStack S){
    
    
    if(S.base != S.top) return *(S.top - 1);
}

链栈

存储结构

#define ElemType int
typedef struct StackNode{
    
    
    ElemType data;
    struct StackNode *next;
}StackNode, *LinkStack;

初始化

void InitStack(LinkStack &S){
    
    
    S = NULL;
}

入栈

void Push(LinkStack &S, ElemType e){
    
    
    StackNode *p = new StackNode;
    p->data = e;
    p->next = S;
    S = p;
}

出栈

bool Pop(LinkStack &S, ElemType &e){
    
    
    if(S == NULL) return false;
    e = S->data;
    StackNode *p = S;
    S = S->next;
    delete p;
    return true;
}

获取栈顶元素

ElemType getTop(LinkStack S){
    
    
    if(S != NULL){
    
    
        return S->data;
    }
}

队列

循环队列

存储结构

#define MAXSIZE 100
#define ElemType int
typedef struct{
    
    
    ElemType *base;//存储空间的基地址
    int front;//头指针
    int rear;//尾指针
}SqQueue;

初始化

bool InitQueue(SqQueue &Q){
    
    
    Q.base = new ElemType[MAXSIZE];
    if(!Q.base){
    
    
        cout << "初始化失败" << endl;
        return false;
    }
    Q.front = Q.rear = 0;
    return true;
}

获取队列长

int getLength(SqQueue Q){
    
    
    return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;
}

入队

bool EnQueue(SqQueue &Q, ElemType e){
    
    
    if((Q.rear + 1) % MAXSIZE == Q.front){
    
    
        cout << "队满" << endl;
        return false;
    }
    Q.base[Q.rear] = e;
    Q.rear = (Q.rear + 1) % MAXSIZE;
    return true;
}

出队

bool DeQueue(SqQueue &Q, ElemType &e){
    
    
    if(Q.front == Q.rear){
    
    
        cout << "队空" << endl;
        return false;
    }
    e = Q.base[Q.front];
    Q.front = (Q.front + 1) % MAXSIZE;
    return true;
}

获取队头元素

ElemType getElem(SqQueue Q){
    
    
    if(Q.front != Q.rear){
    
    
        return Q.base[Q.front];
    }
}

链队

存储结构

#define ElemType int
typedef struct QNode{
    
    
    ElemType data;
    struct QNode *next;
}QNode, *QueuePtr;
typedef struct{
    
    
    QueuePtr front;
    QueuePtr rear;
}LinkQueue;

初始化

void InitQueue(LinkQueue &Q){
    
    
    Q.front = Q.rear = new QNode;
    Q.front->next = NULL;
}

入队

void EnQueue(LinkQueue &Q, ElemType e){
    
    
    QNode *p = new QNode;//创建新节点
    p->data = e;
    p->next = NULL;
    Q.rear->next = p;//连接新节点
    Q.rear = p;//尾指针后移
}

出队

bool DeQueue(LinkQueue &Q, ElemType &e){
    
    
    if(Q.front == Q.rear) return false;
    QNode *p = Q.front->next;//保存节点
    e = p->data;//将节点数据保存
    Q.front->next = p->next;//指针后移
    if(Q.rear == p) Q.rear = Q.front;//如果到队尾，更新
    delete p; //删除节点
    return true;
}

获取队头元素

ElemType getElem(LinkQueue Q){
    
    
    if(Q.front != Q.rear) return Q.front->next->data;
}