队列(循环队列和链队)

顺序队列一般实现为循环队列,因为普通的队列可能产生“假溢出”。

1 struct SqQueue{
2     int data[maxSize];
3     int front;
4     int rear;
5 };

循环队列的两个状态:

1.队空

qu.rear == qu.front

2.队满  (注意,循环队列必须损失一个存储空间,用来区分队空和堆满,如果队列中的所有空间对被占满,那么队空和队满的状态都是qu.front == qu.rear,导致无法区分)

(qu.rear+1)%maxSize == qu.front

循环队列的两个操作:

1.进队

1 qu.rear = (qu.rear+1)%maxSize     //  先移动指针,再存储元素
2 qu.data[qu.rear] = x;

2.出队

1 x = qu.data[qu.front];              //  先取元素,再移动指针
2 qu.front = (qu.front+1)%maxSize;

相关操作:

 1 void InitQueue(SqQueue &qu)
 2 {
 3     qu.front = qu.rear = 0;
 4 }
 5 
 6 int QueueEmpty(SqQueue qu)
 7 {
 8     if(qu.front==qu.rear)
 9         return 1;
10     else
11         return 0;
12 }
13 
14 int enQueue(SqQueue &qu,int x)
15 {
16     if((qu.rear+1)%maxSize == qu.front)  // 若队满,就不可再添加了
17         return 0;
18     qu.rear = (qu.rear+1)%maxSize;   // 先移动指针,在存入元素
19     qu.data[qu.rear]=x;
20     return 1;
21 }
22 
23 int deQueue(SqQueue &qu,int &x)
24 {
25     if(qu.front == qu.rear)    // 若队空,就不可以删除了
26         return 0;
27     x = qu.data[qu.front];            // 先取出元素,再移动指针
28     qu.front = (qu.front+1)%maxSize;
29     return 1;
30 }

还有一个计算循环队列中实际元素个数的式子:

1  n = (qu.rear - qu.front + maxSize) % maxSize;

 

链队

两个状态:

1.队空

lqu->rear == NULL 或 lqu->front == NULL

2.队满

不存在队满的情况。

两个操作:

1.进队 (假设p指向进队元素)

1 lqu->rear->next = p;
2 lqu->rear = p;

2.出队 (假设p指向出队元素,也就是队首元素)

1 p = lqu->front;
2 lqu->front = p->next;
3 x = p->data;
4 free(p);

 

相关操作:

 1 //先定义结点
 2 struct QNode{
 3     int data;
 4     QNode *next;
 5 };
 6 // 定义链队
 7 struct LQueue
 8 {
 9     QNode *front;
10     QNode *rear;
11 };
12 
13 void Init(LQueue *&lqu)
14 {
15     lqu = new LQueue;
16     lqu->front = lqu->rear = NULL;
17 }
18 
19 int QueueEmpty(LQueue *lqu)
20 {
21     if(lqu->front == NULL||lqu->rear == NULL)
22         return 1;
23     else 
24         return 0;
25 }
26 
27 void enQueue(LQueue *&lqu,int x)
28 {
29     QNode *p = new QNode;
30     p->data = x;
31     p->next = NULL;
32     if(lqu->rear == NULL)
33         lqu->front = lqu->rear = p;
34     else{
35         lqu->rear->next = p;
36         lqu->rear = p
37     }
38 }
39 
40 int deQueue(LQueue *&lqu,int &x)
41 {
42     QNode *p;
43     if(lqu->rear == NULL)
44         return 0;
45     else
46         p=lqu->front;
47 
48     if(lqu->front == lqu->rear)      // 当链队中只有一个结点时,特殊处理
49         lqu->front=lqu->rear=NULL;
50     else
51         lqu->front = lqu->front->next;
52     x=p->data;
53     free(p);
54     return 1;
55 }
posted @ 2018-09-26 15:31  朴者  阅读(2023)  评论(0编辑  收藏  举报