栈与队列 2 - 2020-4-13- 算法 06

栈的应用思想

• 数据是线性的
• 问题中常常涉及到数据的来会比较，匹配问题；
• 问题中涉及到数据的转置
• 利用栈的思想解决问题是，首先需要透彻的解析问题后，找到问题解决的规律

队列假溢出问题以及循环队列的空/满判断推理

• 循环队列判空 Q.rear = Q.front
• 循环队列判满 (Q.rear + 1)%MAXSIZE = Q.front

队列的顺序存储设计

//顺序存储解决队列结构
typedef struct{
    //开辟连续空间存储队列数据内容；
    QElemType data[MAXSIZE];
    //设置索引
    int front; //队头
    int rear; //队尾
}SqQueue;
//初始化空队列
Status InitQueue(SqQueue *Q){
    Q->front = Q->rear = 0;
    return OK;
}
//置空
Status ClearQueue（SqQueue *Q){
    Q->front = Q->rear = 0;
    return OK;
}
//判断队列是否为空
Status QueueEmpty(SqQueue Q){
    if(Q.rear == Q.front) return TRUE;
    
    return FALSE;
}
//判断队列的长度
int QueueLength(SqQueue Q){
    return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;
}
//获取队头
Status GetHead(SqQueue Q,QElemType *e){
    if(Q.front == Q.rear) return ERROR;
    *e = Q.data[Q.front];
    return OK;
}
//入队
Status EnQueue(SqQueue *Q,QElemType *e){
    if((Q->rear +1) % MAXSIZE == Q->front) return ERROR; //队列已满
    Q->data[Q->rear] = e;
    Q->rear = ((Q->rear) + 1 ) % MAXSIZE;
    return OK;
}
//出队
Status QnQueue(SqQueue *Q,QElemType *e){
    if(Q->front == Q->rear) return ERROR;
    *e = Q->data[Q->front];
    Q->front = (Q->front + 1) % MAXSIZE;
    return OK;
}
//遍历
void TraverseQueue(SqQueue Q){
    printf("\n");
    int i;
    i=Q.front;
    while((i+Q.front) != Q.rear){
        printf("%d",Q.data[i]);
        i = (i+1)%MAXSIZE;
    }
    printf("\n");
}

链式存储设计

typedef struct QNode{
    QElemType data;
    struct QNode *next;
}QNode,*QueuePtr;
//队列的链表结构
typedef struct{
    QueuePtr front;
    QueuePtr rear;
}LinkQueue;

//链式队列初始化
Status InitQueue(LinkQueue *Q){
    //头结点
    Q->rear = Q->front = (QueuePtr)malloc(sizeof(QNode));
    if(!Q->front && !Q->rear) return ERROR;
    Q->front->next = NULL;
    return OK;
}
//销毁队列
Status destroyQueue(LinkQueue *Q){
    while(Q->front){
    //Q->rear 作为一个temp
        Q->rear = Q->front->next;
        free(Q->front);
        Q->front = Q->rear;
    }
    return OK;
}
//清空队列
Status ClearQueue(LinkQueue *Q){
    QueuePtr p,q;
    Q->rear = Q->front;
    p = Q->fron->next;
    Q->front->next = NULL;
    while(p){
        q = p;
        p = p->next;
        free(q);
    }
    return OK;
}
//判断是否为空
Status QueueEmpty(LinkQueue Q){
    if(Q.front == Q.rear) return TRUE;
    return ERROR;
}
//计算队列长度
int QueueLength(LinkQueue Q){
    int i =0;
    QueuePtr p;
    p = Q.front;
    while(Q.rear != p){
        i++;
        p = p->next;
    }
    return i;
}
//入队
Status EnQueue(LinkQueue *Q,QElemtype e){
    QueuePtr s = (QueuePtr)malloc(sizeof(QNode));
    if(!s) return ERROR;
    s->data = e;
    s->next = NULL;
    Q->rear->next = s;
    Q->rear =s;
    return OK;
}
//出队
Status DeQueue(LinkQueue *Q,QElemType *e){
    if(Q->rear == Q->front) return ERROR;
    QueuePtr p;
    p = Q->front->next;
    *e = p->data;
    Q->front->next =p->next;
    if(Q->rear == p) Q->rear = Q->front; //只剩一个结点的时候
    free(p);
    return OK;
}
//获取头
Status GetHead(LinkQueue Q,QElemType *e){
    if(Q->front != Q->rear){
        *e = Q.front->next->data;
        return TRUE;
    }
    return FALSe;
}
//遍历
Status QueueTraverse(LinkQueue Q){
    printf("\n");
    QueuePtr p;
    p=Q.front->next;
    while(p){
        printf("%d",p->data);
        p=p->next;
    }
    printf("\n");
    return OK;
}