队列ADT

队列ADT

FIFO (先进先出)

typedef struct queueCDT * queueADT;

入队：



出队：



循环队列：



只凭front与rear是否相等，无法判断队列是满还是空。

1、增加标志位：当数据入队列后，出现front与rear相等，设置标志位。

2、少用一个存储单元：当front在rear的下一位置即表示队列已满

求取元素个数：

只需要将队尾值rear减去队头值front即可，得到的差值即表示元素个数。

若差值为负数，只需要加上存储空间的大小。

顺序队列的实现：

5 typedef int queueElementT;
6 typedef struct queueCDT * queueADT;

4 #define MAXQSIZE 100

5 struct queueCDT{
6 queueElementT *data;
7 int front;
8 int rear;
9 };

初始化队列：

1 queueADT newQueue(void)
12 {
13 queueADT queue;
14 queue = (queueADT)malloc(sizeof(struct queueCDT));
15 queue -> data = (queueElementT*)malloc(MAXQSIZE * sizeof(queueElementT));
16 queue -> front = 0;
17 queue -> rear = 0;
18 return queue;
19 }

入队，出队：

27 bool inQueue(queueADT queue, queueElementT value)
28 {
29 if(queueIsFull(queue)) {
30 return false;
31 }
32 queue -> data[queue -> rear] = value;
33 queue -> rear = (queue->rear + 1) % MAXQSIZE;
34 return true;
35 }

37 bool outQueue(queueADT queue, queueElementT *p_value)
38 {
39 if(queueIsEmpty(queue)) {
40 return false;
41 }
42 *p_value = queue -> data[queue -> front];
43 queue -> front = (queue -> front + 1) % MAXQSIZE;
44 return true;
45 }

判空，判满：

47 bool queueIsEmpty(queueADT queue)
48 {
49 return (queue -> rear == queue -> front);
50 }

52 bool queueIsFull(queueADT queue)
53 {
54 return ((queue->rear + 1) % MAXQSIZE == queue -> front);
55 }

求长度

57 size_t getQueueLength(queueADT queue)
58 {
59 return (queue -> rear – queue -> front + MAXQSIZE) % MAXQSIZE;
60 }

链队列：

定义队列结构体：

struct queueCDT{
slist_head_t list_head; /* 链表头 */
};

链表结点类型：

typedef struct _queue_node_t{
slist_node_t node;
int data;
} queue_node_t

15 queueADT newQueue(void)
16 {
17 queueADT queue;
18 queue = (queueADT)malloc(sizeof(struct queueCDT));
19 slist_init(&queue -> list_head);
20 return queue;
21 }

33 bool inQueue(queueADT queue, queueElementT value)
34 {
35 if(queueIsFull(queue)) {

4000
36 return false;
37 }
38 queue_node_t *p_node = (queue_node_t *)malloc(sizeof(queue_node_t));
39 p_node -> data = value;
40 slist_add_tail(&queue -> list_head, &(p_node -> node));
41 return true;
42 }

56 bool queueIsEmpty(queueADT queue)
57 {
58 return (slist_begin_get(&queue -> list_head) == slist_end_get(&queue -> list_head));
59 }

67 static int _numElems_node(void *p_arg, slist_node_t *p_node)
68 {
69 (*(size_t *)p_arg)++;
70 return 0;
71 }

在入队列函数的实现中，每次都需要将新的结点添加至链表尾部，而对于单向链表，直接将结点添加至链表尾部的效率是非常低的，每次都需要从头开始遍历，直到找到最后一个结点，才能执行 实际的添加操作。解决：双向链表