第4天队列

      队列是一种先进先出的线性表，只能在表头删除在表尾插入，操作系统中的作业排队就是队列的一个很好的应用。

     也有可以在两端均可进行插入和删除操作的队列，称为双端队列，但其用处并没有一般队列广泛。

 

 

队列类型的实现

1：链队列——链式映象:

2：循环队列——顺序映象

 

 

第一部分：链队列——链式映象

算法1：队列的数据结构

1 typedef struct QNode {// 结点类型
2     QElemType    data;
3     struct QNode  *next;
4   } QNode, *QueuePtr;

1 typedef struct { // 链队列类型
2     QueuePtr  front;  // 队头指针
3     QueuePtr  rear;   // 队尾指针
4 } LinkQueue
5 
6 空队列的判断条件是：Q.front＝＝Q.rear

 

算法2：InitQueue(&Q):操作结果：构造一个空队列Q。

1 Status InitQueue (LinkQueue &Q) {
2 // 构造一个空队列Q
3  Q.front = Q.rear =(QueuePtr)malloc(sizeof(QNode));
4  if (!Q.front) exit (OVERFLOW);                                                               
5  Q.front->next = NULL;
6  return OK;}

 

算法3：为队列插入元素为新的队尾元素

 1 Status EnQueue (LinkQueue &Q, QElemType e)
 2 { // 插入元素e为Q的新的队尾元素
 3     p = (QueuePtr) malloc (sizeof (QNode));
 4     if (!p)  exit (OVERFLOW); 
 5      p->data = e;   
 6      p->next = NULL;
 7      Q.rear->next = p;    
 8      Q.rear = p;
 9    return OK;
10  }
11 
12  

 

算法4：DeQueue(&Q, &e) 操作结果：删除Q的队头元素，并用e返回其值。

初始条件：Q为非空队列。

 1 Status DeQueue (LinkQueue &Q, QElemType &e) 
 2 {// 若队列不空，则删除Q的队头元素，
 3   //用 e 返回其值，并返回OK；否则返回ERROR
 4    if (Q.front == Q.rear)    return ERROR;
 5    p = Q.front->next;   
 6    e = p->data;
 7    Q.front->next = p->next;
 8    if (Q.rear = = p)  
 9    Q.rear = Q.front;
10     free (p);     
11    return OK;
12 ）

 

第二部分：循环队列——顺序映象

（1）用一组地址连续的存储单元依次存放从队头到队尾的元素，同时附设两个指针front 和rear分别指示队头元素和队尾元素的位置。

（2）当队列为空时：front=rear=0

（3）当插入元素时：队尾指针增加1；

（4）当删除元素时：队头指针增加1；

（5）因此：队头指针始终指向队头元素；而队尾指针始终指向队尾元素的下一位置。

算法1：队列的数据结构

1 #define MAXQSIZE  100  //最大队列长度
2     typedef struct {
3     QElemType  *base;  // 动态分配存储空间
4     int  front;     // 头指针，若队列不空，
5                         //  指向队列头元素
6     int  rear;      // 尾指针，若队列不空，指向
7                        // 队列尾元素 的下一个位置
8   } SqQueue

判断队满的方法：

1、设一个标志位；

2、浪费一个元素空间，约定队列头指针在队尾指针的下一位置时，表示队列满即：

(Q.rear+1) % MAXQSIZE = = Q.front是队满的判断条件

(Q.rear+1) mod maxsize=Q.front

算法2：创造一个新的队列

1 Status InitQueue (SqQueue &Q)
2  { // 构造一个空队列Q
3 Q.base = (ElemType *) malloc(MAXQSIZE *sizeof (ElemType));
4 if (!Q.base) exit (OVERFLOW);  // 存储分配失败
5 Q.front = Q.rear = 0;      //队空的条件即
6  return OK;           (Q.front = =Q.rear )
7  }

算法3：队列插入元素

1 Status EnQueue (SqQueue &Q,  ElemType e)
2  {   // 插入元素e为Q的新的队尾元素
3   if ((Q.rear+1) % MAXQSIZE = = Q.front) 
4   return ERROR; //队列满
5   Q.base[Q.rear] = e;
6   Q.rear = (Q.rear+1) % MAXQSIZE;
7   return OK;
8   }

算法4：队列插入删除元素

Status DeQueue (SqQueue &Q, ElemType &e) 
{  // 若队列不空，则删除Q的队头元素，
   // 用e返回其值，并返回OK;  否则返回ERROR
if (Q.front == Q.rear)  return ERROR;
e = Q.base[Q.front];
Q.front = (Q.front+1) % MAXQSIZE;
return OK;
}

 

转载于:https://www.cnblogs.com/hellochennan/p/5378819.html