数据结构：队列顺序存储和链式存储实现_队列的顺序存储和链式存储的实现详细

一、链式队列

1、存储结构

#define ElemType int
#define Maxsize 50

typedef struct Linknode
{
	ElemType data;
	struct Linknode *next;
}Linknode;

typedef struct
{
	Linknode *rear, *front;
}LinkQueue;
1
2
3
4
5
6
7
8
9
10
11
12
13

这里是先创建一个结点，在将这个结点再次封装成队头和队尾结点
在内存中的形式如下

这样可以非常直观的将队列的形式表达出来

2、基本操作

1）初始化

void InitQueue(LinkQueue &Q)
{
	Q.front = Q.rear = (Linknode*)malloc(sizeof(Linknode));//建立头节点
	Q.front->next = NULL;//初始化为空
}
1
2
3
4
5

2）判空

bool IsEmpty(LinkQueue &Q)
{
	if (Q.front == Q.rear)
	{
		cout << "IsEmpty队列为空" << endl;
		return true;
	}
	else return false;
}
1
2
3
4
5
6
7
8
9

3）入队

void EnQueue(LinkQueue &Q, ElemType e)
{
	Linknode *temp = (Linknode*)malloc(sizeof(Linknode));
	temp->data = e;//创建新节点
	temp->next = NULL;
	Q.rear->next = temp;//插入到队尾
	Q.rear = temp;
}
1
2
3
4
5
6
7
8

4）出队

bool DeQueue(LinkQueue &Q)
{
	if (IsEmpty(Q) == true)
	{
		cout << "DeQueue队列为空" << endl;
		return false;//判段队列是否为空，为空返回报错
	}
	Linknode *temp = (Linknode*)malloc(sizeof(Linknode));//创建新结点用来记录队列第一个结点的位置
	temp = Q.front->next;
	cout << "出队："<<temp->data << endl;//出队
	Q.front->next = temp->next;
	if (Q.rear == temp)//如果此时队列为空，则变为空队列
	{
		Q.rear = Q.front;
	}
	free(temp);//释放这个结点
	return true;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

5）代码合集

#include<iostream>
#include<string.h>
#include<windows.h>
using namespace std;

#define ElemType int
#define Maxsize 50

typedef struct Linknode
{
	ElemType data;
	struct Linknode *next;
}Linknode;

typedef struct
{
	Linknode *rear, *front;
}LinkQueue;

//bool init(SqQueue &Q)

void InitQueue(LinkQueue &Q)
{
	Q.front = Q.rear = (Linknode*)malloc(sizeof(Linknode));//建立头节点
	Q.front->next = NULL;//初始化为空
}

bool IsEmpty(LinkQueue &Q)
{
	if (Q.front == Q.rear)
	{
		cout << "IsEmpty队列为空" << endl;
		return true;
	}
	else return false;
}

void EnQueue(LinkQueue &Q, ElemType e)
{
	Linknode *temp = (Linknode*)malloc(sizeof(Linknode));
	temp->data = e;//创建新节点
	temp->next = NULL;
	Q.rear->next = temp;//插入到队尾
	Q.rear = temp;
}

bool DeQueue(LinkQueue &Q)
{
	if (IsEmpty(Q) == true)
	{
		cout << "DeQueue队列为空" << endl;
		return false;//判段队列是否为空，为空返回报错
	}
	Linknode *temp = (Linknode*)malloc(sizeof(Linknode));//创建新结点用来记录队列第一个结点的位置
	temp = Q.front->next;
	cout << "出队："<<temp->data << endl;//出队
	Q.front->next = temp->next;
	if (Q.rear == temp)//如果此时队列为空，则变为空队列
	{
		Q.rear = Q.front;
	}
	free(temp);//释放这个结点
	return true;

}

int main()
{
	LinkQueue Q;
	InitQueue(Q);
	IsEmpty(Q);
	DeQueue(Q);
	EnQueue(Q, 1);
	EnQueue(Q, 2);
	EnQueue(Q, 3);
	EnQueue(Q, 4);
	DeQueue(Q);
	DeQueue(Q);
	DeQueue(Q);
	DeQueue(Q);
	
	return 0;
}
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

最终结果

二、顺序队列

1、存储结构

这里想所采取的措施是想实现循环队列

#define ElemType int
#define Maxsize 15

typedef struct
{
	ElemType data[Maxsize];
	int front, rear;
}SqQueue;
1
2
3
4
5
6
7
8

2、基本操作

1）初始化

void init(SqQueue &Q)
{
	Q.front = Q.rear = 0;
}
1
2
3
4

2）判空

bool IsEmpty(SqQueue &Q)
{
	if (Q.front == Q.rear)
	{
		cout << "队空" << endl;
		return true;
	}
	else return false;
}
1
2
3
4
5
6
7
8
9

3）入队

bool  EnQueue(SqQueue &Q, ElemType e)
{
	//进队，先判断队列是否满了
	if ((Q.rear + 1) % Maxsize == Q.front)
	{
		cout << "队满" << endl;
		return false;
	}
	Q.data[Q.rear] = e;
	Q.rear = (Q.rear+1) % Maxsize;
	return true;
}
1
2
3
4
5
6
7
8
9
10
11
12

4）出队

bool DeQueue(SqQueue &Q)
{
	//出队，判断队列是否为空
	if (IsEmpty(Q) == true)
		return false;

	cout << Q.data[Q.front];
	Q.front = (Q.front + 1) % Maxsize;
	return true;
}
1
2
3
4
5
6
7
8
9
10

5）代码合集

#include<iostream>
#include<string.h>
#include<windows.h>
using namespace std;

#define ElemType int
#define Maxsize 15
//顺序队列

typedef struct
{
	ElemType data[Maxsize];
	int front, rear;
}SqQueue;

void init(SqQueue &Q)
{
	Q.front = Q.rear = 0;
}


bool IsEmpty(SqQueue &Q)
{
	if (Q.front == Q.rear)
	{
		cout << "队空" << endl;
		return true;
	}
	else return false;
}

bool  EnQueue(SqQueue &Q, ElemType e)
{
	//进队，先判断队列是否满了
	if ((Q.rear + 1) % Maxsize == Q.front)
	{
		cout << "队满" << endl;
		return false;
	}
	Q.data[Q.rear] = e;
	Q.rear = (Q.rear+1) % Maxsize;
	return true;
}

bool DeQueue(SqQueue &Q)
{
	//出队，判断队列是否为空
	if (IsEmpty(Q) == true)
		return false;

	cout << Q.data[Q.front];
	Q.front = (Q.front + 1) % Maxsize;
	return true;
}

int main()
{
	SqQueue Q;
	init(Q);
	IsEmpty(Q);
	EnQueue(Q, 0);
	EnQueue(Q, 1);

	DeQueue(Q);
	DeQueue(Q);
	return 0;
}

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