数据结构与算法----队列

只允许在一端进行插入，一端进行删除。（先进先出）

基本操作

InitQueue(&Q):初始化队列。

DestroyQueue(&Q):销毁队列。

EnQueue（&Q,x）:入队，将x加入成为新的队尾。

DeQueue(&Q,&x):出队，删除队头元素，用x将之返回。

GetHead（Q,&x）:读队头元素，将队头元素赋给x。

#define MaxSize 10
typedef struct{
    ElemType data[MaxSize];
    int front,rear;//rear是指向哪是队尾元素还是队尾元素的下一个位置。
}SqQueue;
//初始化队列
void InitQueue(SqQueue &Q){
    Q.rear=Q.front=0;
}
//判断是否为空
bool QueueEmpty(SqQueue Q){
    if(Q.rear=Q.front){
        return true;
    }else{
        return false;
    }
}
//入队
bool EnQueue(SqQueue &Q,ElemType x){
    if(队列已满）{
        return false;
    }
    Q.data[Q.rear]=x;
    Q.rear = Q.rear+1;
    //Q.rear = (Q.rear+1)%MaxSize; 循环队列。
    //队列已满的条件：（Q.rear+1)%MaxSize==Q.front
    return true;
}
//出队
bool DeQueue(SqQueue &Q,ElemType &x){
    if(Q.rear==Q.front){
        return false;
    }
    Q.data[Q.front]=x
    Q.front=(Q.front+1)%MaxSize;
    // 循环队列。
    return true;
}
//获得队头的元素，用x返回
bool GetHead(SqQueue Q,ElemType &x){
    if(Q.rear==Q.front){
        return false;
    }
    x=Q.data[Q.front];
    return ture;
}

队列元素个数：（rear+MaxSize-front）%MaxSize

队列的链式实现

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;
}
void testLinkQueue(){
    LinkQueue Q;
    InitQueue(Q);
}
//入队
bool EnQueue(LinkQueue &Q,ElemType x){
    LinkNode *s=(LinkQueue *)malloc(sizeof(LinkNode));
    s->data=x;
    s->next=NULL;
    Q.rear->next=s;
    Q.rear=s;
}
//出队
bool DeQueue(LinkQueue &Q,ElemType &x){
    if(Q.front=Q.rear)
        return false;
    LinkNode *p=Q.front->next;
    x=p->data;
    Q.front->next=p->next;
    if(Q.rear==p)
        Q.rear=Q.front;
    free(q);
    return true;
}

双端队列

只允许从两端插入，两端删除的线性表

输入受限的双端队列：只允许从一端插入，两端删除的线性表。

输出受限的双端队列：只允许从两端插入，一端删除的线性表。

循环队列

判空，判满，判断队列中元素的数量

判满方法：1.牺牲一个存储单元（rear+1）%MaxSize==front

使用条件：

队头队尾指向一个位置时候，队空（front==rear）；

队头指针在队尾指针的下一个位置时，队满MaxSize为6；但是要牺牲一个最多只能存5个；

队列中元素的个数（rear-front+maxSize）%MaxSize

方法3：辅助变量记录队列数量

方法3：tag表明由于出队导致的rear==front（队空）还是入队导致的（队满）

应用

树的层次遍历

图的广度优先遍历

FCFS（先来先服务）

矩阵的压缩存储

数组的存储结构

• 一维数组

各数组元素大小相同，且物理上连续存放。

• 二维数组

特殊矩阵

• 对称矩阵

只存储主对角线+下三角区，按行优先原则将各元素存入一维数组中。

数组大小：（1+n）*n/2

• 三角矩阵

下三角矩阵，上三角矩阵，按行优先原则存入一维数组，并在最后一个位置存储常量c

数组大小：1+2+……+n+1

上三角：n(n+1)/2数组位置

• 三对角矩阵

  按行优先原则，只存储带状部分--上三角元素

  前i-1共有3（i-1）-1个元素

  aij是第j-i+2个元素。

• 稀疏矩阵

  三元组存储<行，列，值>；

  十字链表法；