队列的链式存储_队列地链式存储

队列的链式存储

队列也是一种特殊的线性表，队列相比于链表，是在链表的一端插入元素，另外一端取出元素，遵循“先进先出”的原则，与栈相反，队列的存储也用到了链表的API函数

//头文件1-链表的api函数及定义的节点
#ifndef _MYLINKLIST_H_
#define _MYLINKLIST_H_

typedef void LinkList;
typedef struct _tag_LinkListNode
{
	struct _tag_LinkListNode* next;
}LinkListNode;
LinkList* LinkList_Create();
void LinkList_Destroy(LinkList* list);
void LinkList_Clear(LinkList* list);
int LinkList_Length(LinkList* list);
int LinkList_Insert(LinkList* list, LinkListNode* node, int pos);
LinkListNode* LinkList_Get(LinkList* list, int pos);
LinkListNode* LinkList_Delete(LinkList* list, int pos);
#endif

//头文件2-链式队列的api函数声明
#ifndef _MY_LINKQUEUE_H
#define _MY_LINKQUEUE_H
typedef void LinkQueue;
LinkQueue* LinkQueue_Create();
void LinkQueue_Destroy(LinkQueue* queue);
void LinkQueue_Clear(LinkQueue* queue);
int LinkQueue_Append(LinkQueue* queue, void* item);
void* LinkQueue_Retrieve(LinkQueue* queue);
void* LinkQueue_Header(LinkQueue* queue);
int LinkQueue_Length(LinkQueue* queue);
#endif

//c文件1-链表的api函数的实现
#include<iostream>
#include"LinkList.h"
using namespace std;
typedef struct _tag_LinkList
{
	LinkListNode header;
	int length;
}TLinkList;
LinkList* LinkList_Create()
{
	TLinkList* tmp = NULL;
	tmp = (TLinkList*)malloc(sizeof(TLinkList));
	if (tmp == NULL)
	{
		cout << "LinkList_Create() error" << endl;
		return NULL;
	} 
	memset(tmp, 0, sizeof(TLinkList)); 
	return tmp;
}
void LinkList_Destroy(LinkList* list)
{
	if (list == NULL)
	{
		return;
	}
	free(list);
	return;
}
void LinkList_Clear(LinkList* list)
{
	TLinkList* tlist = NULL;
	tlist = (TLinkList*)list;
	if (tlist == NULL)
	{
		return;
	}
	tlist->header.next = NULL;
	tlist->length = 0;
	return;
}
int LinkList_Length(LinkList* list)
{
	TLinkList* tlist = NULL;
	tlist = (TLinkList*)list;
	if (tlist == NULL)
	{
		return -1;
	}
	return tlist->length;
}
int LinkList_Insert(LinkList* list, LinkListNode* node, int pos)
{
	int i = 0;
	LinkListNode *pcur=NULL;
	TLinkList* tList = NULL;
	tList = (TLinkList*)list;
	pcur = &(tList->header);
	if (list == NULL || node == NULL || pos < 0)
	{
		return -1;
	}
	for (i = 0; i < pos; i++)
	{
		pcur = pcur->next;
	}
	node->next = pcur->next;
	pcur->next = node;
	tList->length++;
	return 0;
}
LinkListNode* LinkList_Get(LinkList* list, int pos)
{
	int i = 0;
	LinkListNode* pcur = NULL;
	TLinkList* tList = NULL;
	tList = (TLinkList*)list;
	pcur = &(tList->header);
	if (list == NULL ||  pos < 0)
	{
		return NULL;
	}
	for (i = 0; i < pos; i++)
	{
		pcur = pcur->next;
	}
	return pcur->next;
}
LinkListNode* LinkList_Delete(LinkList* list, int pos)
{
	int i = 0;
	LinkListNode* pcur = NULL;
	LinkListNode* ret = NULL;
	TLinkList* tlist=NULL;
	tlist = (TLinkList*)list;
	pcur = &(tlist->header);
	if (list == NULL || pos < 0)
	{
		return NULL;
	}
	for (i = 0; i < pos; i++)
	{
		pcur = pcur->next;
	}
	ret=pcur->next;
	pcur->next = ret->next;
	tlist->length--;
	//free(ret);
	return ret;
}

//c文件2-链式队列的api函数的实现
#include<iostream>
using namespace std;
#include"LinkQueue.h"
#include"LinkList.h"

//����һ�������൱�ڴ���һ�����Ա�
LinkQueue* LinkQueue_Create()
{
	return LinkList_Create();
}
void LinkQueue_Destroy(LinkQueue* queue)
{
	LinkQueue_Clear(queue);
	LinkList_Destroy(queue);
	return ;
}
void LinkQueue_Clear(LinkQueue* queue)
{
	while (LinkList_Length(queue)>0)
	{
		LinkQueue_Retrieve(queue);
	}
	return ;
}
//�����β������Ԫ�أ��൱����������β������Ԫ�أ���Ҫ�Ѷ��еĽڵ�����������Ľڵ㣬Ȼ����뵽��������
typedef struct _tag_LinkQueueNode
{
	LinkListNode node;
	void* item;
}TLinkQueueNode;
int LinkQueue_Append(LinkQueue* queue, void* item)
{
	int ret = 0;
	TLinkQueueNode* tmp = NULL;
	tmp = (TLinkQueueNode*)malloc(sizeof(TLinkQueueNode));
	if (tmp == NULL)
	{
		return -1;
	}
	tmp->item = item;
	ret=LinkList_Insert(queue, (LinkListNode*)tmp, LinkList_Length(queue));
	if (ret != 0)
	{
		cout << "func LinkList_Insert() error" << endl;
		free(tmp);
		return ret;
	}
	return ret;
}
//ɾ������ͷ��Ԫ��
void* LinkQueue_Retrieve(LinkQueue* queue)
{
	TLinkQueueNode* tmp = NULL;
	void* item = NULL;
	tmp = (TLinkQueueNode*)LinkList_Delete(queue, 0);//�ӵ�0��λ�õ�ָ�룬������Ҫ�ͷ�
	if (tmp == NULL)
	{
		return NULL;
	}
	item = tmp->item;
	free(tmp);//��Ҫ���dz�����ʱ���ڵ��ͷ�
	return item;
}
void* LinkQueue_Header(LinkQueue* queue)
{
	TLinkQueueNode* tmp = NULL;
	tmp = (TLinkQueueNode*)LinkList_Get(queue, 0);
	if (tmp == NULL)
	{
		return NULL;
	}
	return tmp->item;
}
int LinkQueue_Length(LinkQueue* queue)
{
	return LinkList_Length(queue);
}

//c文件3-队列的上层测试函数
#include<iostream>
using namespace std;
#include"LinkQueue.h"
int main()
{
	int  a[10], i = 0;
	LinkQueue* queue = NULL;
	for (i = 0; i < 10; i++)
	{
		a[i] = i + 1;
	}
	queue = LinkQueue_Create();
	for (i = 0; i < 10; i++)
	{
		LinkQueue_Append(queue, &a[i]);
	}
	//获取队列的属性
	cout << "lenght: "<<LinkQueue_Length(queue);
	cout << endl;
	cout << "header: "<< *((int*)LinkQueue_Header(queue));
	cout << endl;
	//出队列
	while (LinkQueue_Length(queue)>0)
	{
		int tmp = *(int*)LinkQueue_Retrieve(queue);
		cout << tmp << " ";
	}
	LinkQueue_Destroy(queue);
}
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
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252

运行结果：