队列及其c语言实现

最新推荐文章于 2024-05-26 17:50:00 发布

qing101hua

最新推荐文章于 2024-05-26 17:50:00 发布

阅读量5.5k

点赞数 4

分类专栏：编程 c++

c++ 同时被 2 个专栏收录

83 篇文章 3 订阅

订阅专栏

编程

11 篇文章 0 订阅

订阅专栏

队列的基本概念

队列 (Queue) :也是运算受限的线性表。是一种先进先出 (First In First Out ,简称 FIFO) 的线性表。只允许在表的一端进行插入,而在另一端进行删除。
队首 (front) :允许进行删除的一端称为队首。
队尾 (rear) :允许进行插入的一端称为队尾。

队列中没有元素时称为空队列。在空队列中依次加入元素 a 1 , a 2 , …, a n 之后, a 1 是队首元素, a n 是队尾元素。显然退出队列的次序也只能是 a 1 , a 2 , …, a n ,即队列的修改是依先进先出的原则进行的,如图 3-5 所示。

这里写图片描述

基本操作

创建新队列
判空
进队
出队
清空队
获得队头元素
遍历队
销毁队
队长

顺序队列

利用一组连续的存储单元 ( 一维数组 ) 依次存放从队首到队尾的各个元素,称为顺序队列。对于队列,和顺序栈相类似,也有动态和静态之分。这里介绍静态顺序队列.其类型定义如
下:

typedef int datatype;
#define MAX_QUEUE_SIZE 100
typedef struct queue
{ 
    datatype queue_array[MAX_QUEUE_SIZE];
    int front;
    int rear;
}sp_queue;
 
 1
2
3
4
5
6
7
8

设立一个队首指针 front ,一个队尾指针rear ,分别指向队首和队尾元素。
◆ 初始化: front=rear =0。
◆ 入队:将新元素插入 rear 所指的位置,然后rear 加 1 。
◆ 出队:删去 front 所指的元素,然后加 1 并返回被删元素。
◆ 队列为空: front=rear 。
◆ 队满: rear = MAX_QUEUE_SIZE - 1 或front=rear 。

在非空队列里,队首指针始终指向队头元素,而队尾指针始终指向队尾元素的下一位置。顺序队列中存在“假溢出”现象。因为在入队和出队操作中,头、尾指针只增加不减小,致使被删除元素的空间永远无法重新利用。因此,尽管队列中实际元素个数可能远远小于数组大小,但可能由于尾指针巳超出向量空间的上界而不能做入队操作。该现象称为假溢出。如图 3-6 所示是数组大小为 5 的顺序队列中队首、队尾指针和队列中元素的变化情况。
假溢出现象

代码实现

/* 顺序队列接口定义头文件*/
#define true 1
#define false 0


/* 队的最大长度 */
#define MAX_QUEUE_SIZE 100
/* 队列的数据类型 */
typedef int datatype;

/* 静态链的数据结构 */
typedef struct queue{
    datatype sp_queue_array[MAX_QUEUE_SIZE];
    /* 队头 */
    int front;
    /* 队尾 */
    int rear;
}sp_queue;


/* 静态顺序链的接口定义 */


/* 静态链的初始化 */
sp_queue queue_init();

/* 判断队列是否为空,若为空
 * 返回true
 * 否则返回false
*/
int queue_empty(sp_queue q);


/* 插入元素e为队q的队尾新元素 
 * 插入成功返回true
 * 队满返回false
*/
int queue_en(sp_queue *q, datatype e);


/* 队头元素出队
 * 用e返回出队元素,并返回true
 * 若队空返回false
*/
int queue_de(sp_queue *q, datatype *e);

/* 清空队 */
void queue_clear(sp_queue *q);


/* 获得队头元素
 * 队列非空,用e返回队头元素,并返回true
 * 否则返回false
*/
int get_front(sp_queue, datatype *e );


/* 获得队长 */
int queue_len(sp_queue q);

/* 遍历队 */
void queue_traverse(sp_queue q, void(*visit)(sp_queue q));


void visit(sp_queue s);


/* 接口实现文件 */
#include<stdio.h>
#include<stdlib.h>
#include"sp_queue.h"


sp_queue queue_init()
{
    sp_queue q;
    q.front = q.rear = 0;
    return q;
}



int queue_empty(sp_queue q)
{
    return q.front == q.rear;
}


int queue_en(sp_queue *q, datatype e)
{
    /* 队满 */
    if (q -> rear == MAX_QUEUE_SIZE)
        return false;

    /* 入队 */
    q -> sp_queue_array[q -> rear] = e;
    printf("q.sp_queue_array[%d]=%d\n", q -> rear, e);
    q -> rear += 1;
    return true;

}


int queue_de(sp_queue *q, datatype *e)
{
    /* 队空 */
    if(queue_empty(*q))
        return false;

    /* 出队 */
    q -> rear -= 1;
    *e = q -> sp_queue_array[q -> rear];
    return true;
}


void queue_clear(sp_queue *q)
{
    q -> front = q -> rear = 0;
}


int get_front(sp_queue q, datatype *e)
{
    /* 队空 */
    if(q.front == q.rear)
        return false;

    /* 获取队头元素 */
    *e = q.sp_queue_array[q.front];
    return true;
}


int queue_len(sp_queue q)
{
    return (q.rear - q.front);
}


void queue_traverse(sp_queue q, void (*visit)(sp_queue q))
{
    visit(q);
}

void visit(sp_queue q)
{
    /* 队空 */
    if (q.front == q.rear)
        printf("队列为空\n");

    int temp = q.front;
    while(temp != q.rear)
    {
        printf("%d ",q.sp_queue_array[temp]);
        temp += 1;
    }
    printf("\n");
}



int main()
{
    sp_queue q = queue_init();
    queue_en(&q, 1);
    queue_en(&q, 2);
    printf("length=%d\n", queue_len(q));
    queue_en(&q, 3);
    printf("length=%d\n", queue_len(q));
    queue_en(&q, 4);
    printf("length=%d\n", queue_len(q));
    queue_en(&q, 5);
    printf("length=%d\n", queue_len(q));
    queue_en(&q, 6);
    printf("length=%d\n", queue_len(q));
    queue_traverse(q,visit);
    datatype *e = (datatype *)malloc(sizeof(*e));
    queue_de(&q,e);
    printf("queue_de(),e=%d length=%d\n", *e, queue_len(q));
    queue_traverse(q, visit);
    queue_clear(&q);
    queue_traverse(q, visit);
    printf("length:%d\n", queue_len(q));
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

注意:结构体变量作为函数的参数和其他普通变量一样,值只会在函数体内被修改,想要通过函数更改结构体的值,可以通过结构体指针作为函数的参数实现.

队列的链式表示和实现

队列的链式存储结构简称为链队列,它是限制仅在表头进行删除操作和表尾进行插入操作的单链表。需要两类不同的结点:数据元素结点,队列的队
首指针和队尾指针的结点,如图 3-8 所示。
这里写图片描述
数据元素结点类型定义:

typedef struct q_node{
    datatype data;
    struct q_node *next;
}q_node;
 
 1
2
3
4

指针结点类型:

typedef struct {
    q_node *front;
    q_node *rear;   
}link_queue;
 
 1
2
3
4

链队运算及指针变化

链队的操作实际上是单链表的操作,只不过是删除
在表头进行,插入在表尾进行。插入、删除时分别修改
不同的指针。链队运算及指针变化如图 3-9 所示。

这里写图片描述

代码实现

/* 链式栈接口的定义头文件 */
#define true 1
#define false 0


/* 队列的数据类型 */
typedef int datatype;

/* 静态链的数据结构 */
typedef struct q_node{
    datatype data;
    struct q_node *next;
}q_node,*link_node;

typedef struct l_queue{
    /* 队头指针 */
    q_node *front;
    /* 队尾指针 */
    q_node *rear;
}*link_queue;


/* 静态顺序链的接口定义 */


/* 静态链的初始化 */
link_queue queue_init();

/* 判断队列是否为空,若为空
 * 返回true
 * 否则返回false
*/
int queue_empty(link_queue q);

/* 插入元素e为队q的队尾新元素 
 * 插入成功返回true
 * 队满返回false
*/
int queue_en(link_queue q, datatype e);


/* 队头元素出队
 * 用e返回出队元素,并返回true
 * 若队空返回false
*/
int queue_de(link_queue q, datatype *e);

/* 清空队 */
void queue_clear(link_queue q);

/* 销毁队 */
void queue_destroy(link_queue q);

/* 获得队头元素
 * 队列非空,用e返回队头元素,并返回true
 * 否则返回false
*/
int get_front(link_queue q, datatype *e );


/* 获得队长 */
int queue_len(link_queue q);

/* 遍历队 */
void queue_traverse(link_queue q, void(*visit)(link_queue q));


void visit(link_queue q);



/* 接口的实现文件 */
#include<stdio.h>
#include<stdlib.h>
#include"lp_queue.h"



link_queue queue_init()
{
    /* 新建头结点 */
    link_node new_node = (link_node)malloc(sizeof(q_node));
    new_node -> next = NULL;
    /* 指针结点 */
    link_queue q = (link_queue)malloc(sizeof(*q));
    q -> front = q -> rear = new_node;
    return q;
}


int queue_empty(link_queue q)
{
    return q -> front == q -> rear;
}


int queue_en(link_queue q, datatype e)
{
    /* 新建数据结点 */
    link_node new_node = (link_node)malloc(sizeof(q_node));
    /* 内存分配失败 */
    if(!new_node)
        return false;
    new_node -> data = e;
    q -> rear -> next = new_node;
    q -> rear = new_node;
    return true;
}

int queue_de(link_queue q, datatype *e)
{
    /* 队列为空 */
    if (q -> front == q -> rear)
        return false;

    *e = q -> front -> next -> data;
    link_node temp = q -> front -> next;
    q -> front -> next = temp -> next;
    /* 防止丢失尾指针 */
    if (temp == q.rear -> next)
        q -> rear = q -> front; 
    free(temp);
    temp = NULL;
    return true;
}

void queue_clear(link_queue q)
{
    /* 头结点 */
    link_node head = q -> front -> next;
    head -> next = NULL;
    q -> front = q -> rear = head;
    /* 第一个结点 */
    link_node temp = head -> next;
    while(temp)
    {
        link_node p = temp;
        temp = p -> next;
        free(p);
        p = NULL;
    }
}


void queue_destroy(link_queue q)
{
    queue_clear(q);
    free(q);
    q = NULL;
}


int get_front(link_queue q, datatype *e)
{
    /* 队为空 */
    if (q -> front == q -> rear)
        return false;

    *e = q -> front -> next -> data;
    link_node temp = q -> front -> next;
    q -> front -> next = temp -> next;
    free(temp);
    temp = NULL;
    return true;
}


int queue_len(link_queue q)
{
    /* 头结点 */
    link_node p = q -> front -> next;
    /* 计数器 */
    int count = 0;
    while(p)
    {
        count += 1;
        p = p -> next;
    }
    return count;
}


void queue_traverse(link_queue q, void(*visit)(link_queue q))
{
    visit(q);
}

void visit(link_queue q)
{
    /* 头结点 */
    link_node p = q -> front -> next;
    if(!p)
    {
        printf("队列为空");
    }
    while(p)
    {
        printf("%d ", p -> data);
        p = p -> next;
    }
    printf("\n");
}

int main()
{
    link_queue q = queue_init();
    queue_en(q, 1);
    queue_en(q, 2);
    printf("length=%d\n", queue_len(q));
    queue_en(q, 3);
    printf("length=%d\n", queue_len(q));
    queue_en(q, 4);
    printf("length=%d\n", queue_len(q));
    queue_en(q, 5);
    printf("length=%d\n", queue_len(q));
    queue_en(q, 6);
    printf("length=%d\n", queue_len(q));
    queue_traverse(q,visit);
    datatype *e = (datatype *)malloc(sizeof(*e));
    queue_de(q,e);
    printf("queue_de(),e=%d length=%d\n", *e, queue_len(q));
    queue_traverse(q, visit);
    queue_clear(q);
    queue_traverse(q, visit);
    printf("length:%d\n", queue_len(q));
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226

执行结果:
这里写图片描述

qing101hua

关注

4
点赞
踩
47

收藏

觉得还不错? 一键收藏
2
评论
队列及其c语言实现

队列的基本概念队列 (Queue) :也是运算受限的线性表。是一种先进先出 (First In First Out ,简称 FIFO) 的线性表。只允许在表的一端进行插入,而在另一端进行删除。队首 (front) :允许进行删除的一端称为队首。队尾 (rear) :允许进行插入的一端称为队尾。队列中没有元素时称为空队列。在空队列中依次加入元素 a 1 , a 2 ,
复制链接

扫一扫

专栏目录