顺序队列
顺序队列是用静态数组实现的;结构体里面有前后指针front与rear(前后索引),front用来记录出队的下标,rear用来记录入队的下标
#include<iostream>
using namespace std;
#define max 20
typedef struct myQueue
{
int front;
int rear;
int data[max];
}myQueue;
myQueue* initQueue()
{
myQueue* head = new myQueue;
head->rear = head->front = 0;//初始化首尾索引指针
return head;
}
bool isEmpty(myQueue* head)
{
if (head->rear == 0)//如果队尾索引为0,则队列为空
return 1;
else
return 0;
}
bool isFull(myQueue* head)
{
if (head->rear == max)//如果队尾索引达到最大值max,则队列已满
return 1;
else
return 0;
}
int enQueue(myQueue* head, int x)
{
if (isFull(head))
return 0;
else
{
head->data[head->rear] = x;
head->rear++;//每入队一个元素,队尾索引指向下一个位置
return 1;
}
}
int deQueue(myQueue* head)
{
if (isEmpty(head))
return 0;
else
{
head->front++;//每出队一个元素,front指向下一个位置
return 1;
}
}
void showQueue(myQueue* head)
{
int temp1,temp2;//为了不改变front与rear索引,设置工作索引指针来遍历队列
temp1 = head->front;
temp2 = head->rear;
for ( ; temp1 < temp2; temp1++)
{
cout << head->data[temp1] << " ";
}
cout << endl;
}
int main()
{
myQueue* head = initQueue();
int n;
cin >> n;
for (int i = 0; i < n; i++)
{
int x;
cin >> x;
enQueue(head, x);
}
showQueue(head);
deQueue(head);
deQueue(head);
showQueue(head);
}
链式队列
#include<iostream>
using namespace std;
typedef struct myQueue
{
int data;
struct myQueue* next;
}myQueue;
myQueue* initQueue()
{
myQueue* head = new myQueue;
head->next = NULL;
return head;
}
bool isEmpty(myQueue* head)
{
if (head->next == NULL)
return 1;
else
return 0;
}
int enQueue(myQueue* head, int x)//入队操作类似链表的尾插法
{
myQueue* node = new myQueue;
myQueue* temp = head;
while (temp->next != NULL)//找到最后一个结点
{
temp = temp->next;
}
node->data = x;
node->next = temp->next;
temp->next = node;
return 1;
}
int deQueue(myQueue* head)//出队相当于链表的顺序删除
{
if (isEmpty(head))
return 0;
else
{
myQueue* temp = head->next;
head->next = temp->next;
delete temp;
return 1;
}
}
void showQueue(myQueue* head)
{
myQueue* temp = head->next;//设置工作指针来遍历队列
while(temp!=NULL)
{
cout << temp->data << " ";
temp = temp->next;
}
cout << endl;
}
int main()
{
myQueue* head = initQueue();
int n;
cout << "请输入入队元素的个数:";
cin >> n;
for (int i = 0; i < n; i++)
{
int x;
cout << "请输入入队元素:";
cin >> x;
enQueue(head, x);
}
cout << "队列情况:";
showQueue(head);
cout << "出队一个:";
deQueue(head);
showQueue(head);
}
循环队列:
1、循环队列是队列的顺序存储结构
2、循环队列用判断是否为空利用 Q.front=Q.rear
3、循环队列头指针始终指向队列头元素,而尾指针始终指向队列尾元素的下一个位置
4、按照队列的定义,队头删除,队尾插入
循环队列的结点结构
front与rear为索引指针;front始终指向队列头元素,rear指向队列尾的下一个位置(相当于空)
typedef struct queue
{
int front;
int rear;
int data[MAXSIZE];
}Queue;
初始队列
初始化队头指针front与rear;都赋值为0;并且返回q指针
Queue* initQueue()
{
Queue* q = (Queue*)malloc(sizeof(Queue));
q->front = q->rear = 0;//初始化队头,队尾
return q;
}
判断队列满与空
队列空:q->rear==q->front
队列满:(q->rear + 1) % MAXSIZE == q->front
(q->rear + 1) % MAXSIZE == q->front来实现队列循环的下标---越界问题
//判断队列满
bool isFull(Queue* q)
{//牺牲队列中的一个位置来做如下判断
if ((q->rear + 1) % MAXSIZE == q->front)
{
return 1;
}
else
{
return 0;
}
}
//判断队列空
bool isEmpty(Queue* q)
{
if (q->front == q->rear)
{
return 1;
}
else
{
return 0;
}
}
入队
每次入队后,将队尾rear指向下一个位置,
注意越界问题----(q->rear + 1) % MAXSIZE == q->front
//入队
int enQueue(Queue* q, int x)
{
if (isFull(q))
{
return 0;
}
else
{
q->data[q->rear] = x;
q->rear = (q->rear + 1) % MAXSIZE;
return 1;
}
}
出队
出队后,将front指向下一个位置,
注意越界问题---q->front = (q->front + 1) % MAXSIZE
//出队
int deQueue(Queue* q)
{
if (isEmpty(q))
{
return -1;
}
else
{
int x = q->data[q->front];
q->front = (q->front + 1) % MAXSIZE;
return x;
}
}
遍历队列
队列的长度:队尾 - 队头 + MAXSIZE//防止出现负数的情况
再取余--不超过限制长度---( 队尾 - 队头 + MAXSIZE ) % MAXSIZE
//遍历队列
void printQueue(Queue* q)
{
int length = (q->rear - q->front + MAXSIZE) % MAXSIZE;
int index = q->front;//不能改变front与rear
for (int i = 0; i < length; i++)
{
cout << q->data[index] << "->";
index = (index + 1) % MAXSIZE;//遍历时一样会遇到边界
}
cout << "NULL" << endl;
}
完整的循环队列
#include<iostream>
#include<stdlib.h>
using namespace std;
//C语言实现
#define MAXSIZE 5
typedef struct queue
{
int front;
int rear;
int data[MAXSIZE];
}Queue;
//初始化队列
Queue* initQueue()
{
Queue* q = (Queue*)malloc(sizeof(Queue));
q->front = q->rear = 0;//初始化队头,队尾
return q;
}
//判断队列满
bool isFull(Queue* q)
{//牺牲队列中的一个位置来做如下判断
if ((q->rear + 1) % MAXSIZE == q->front)
{
return 1;
}
else
{
return 0;
}
}
//判断队列空
bool isEmpty(Queue* q)
{
if (q->front == q->rear)
{
return 1;
}
else
{
return 0;
}
}
//入队
int enQueue(Queue* q, int x)
{
if (isFull(q))
{
return 0;
}
else
{
q->data[q->rear] = x;
q->rear = (q->rear + 1) % MAXSIZE;
return 1;
}
}
//出队
int deQueue(Queue* q)
{
if (isEmpty(q))
{
return -1;
}
else
{
int x = q->data[q->front];
q->front = (q->front + 1) % MAXSIZE;
return x;
}
}
//遍历队列
void printQueue(Queue* q)
{
int length = (q->rear - q->front + MAXSIZE) % MAXSIZE;
int index = q->front;
for (int i = 0; i < length; i++)
{
cout << q->data[index] << "->";
index = (index + 1) % MAXSIZE;
}
cout << "NULL" << endl;
}
int main()
{
Queue* q = initQueue();
enQueue(q, 0);
enQueue(q, 1);
enQueue(q, 2);
enQueue(q, 3);
printQueue(q);
deQueue(q);
printQueue(q);
deQueue(q);
printQueue(q);
return 0;
}