队列ADT的两种简单实现

队列在书中说明的方式是两种，一种最简单的链表队列，判断情况比较简单，另一种是使用数组进行创建，限制较多，但是速度较快，也比较容易控制内存，不至于出现在链表实现上那么复杂的内存控制。

下面先是链表实现：

ListQueue.cpp

#include "iostream"
#include "stdlib.h"

typedef struct _queue_
{
int data;
struct _queue_ *next;
}queue;

int isEmpty(queue *front)
{
if (front == nullptr)
return 1;
else
return 0;
}

void enQueue(queue *&front,queue *&rear,int data)
{
queue *p = (queue *)malloc(sizeof(queue));
p->data = data;
p->next = nullptr;
if (front == nullptr)
{
front = p;
rear = p;
return;
}
else
{
rear->next = p;
rear = p;
return;
}
}

void deQueue(queue *&front, queue *&rear)
{
queue *tmp=nullptr;
if (isEmpty(front))
return ;
if (front->next == nullptr)
{
free(front);
front = nullptr;
return;
}
else
{
tmp = front;
front = front->next;
tmp->next = nullptr;
free(tmp);
return;
}
}

int head(queue *front)
{
if (isEmpty(front))
{
std::cout << "队列为空，返回为 ";
return -1;
}
return front->data;
}

int main(void)
{
queue *front = nullptr;
queue *rear = nullptr;
enQueue(front, rear, 1);
enQueue(front, rear, 2);
enQueue(front, rear, 3);
enQueue(front, rear, 4);
enQueue(front, rear, 5);
std::cout << head(front) << std::endl;
deQueue(front, rear);
std::cout << head(front) << std::endl;
deQueue(front, rear);
std::cout << head(front) << std::endl;
deQueue(front, rear);
std::cout << head(front) << std::endl;
deQueue(front, rear);
std::cout << head(front) << std::endl;
deQueue(front, rear);
std::cout << head(front) << std::endl;
deQueue(front, rear);
std::cout << head(front) << std::endl;
system("pause");
return 0;
}

还有数组实现

ArrayQueue.cpp

#include "iostream"
#include "stdlib.h"

typedef struct _queue_
{
int maxSize;
int front;
int rear;
int *Array;
}queue;

queue *createQueue(int maxSize)
{
queue *p = (queue *)malloc(sizeof(queue));
p->Array = (int *)malloc(sizeof(int)*maxSize);
p->front = -1;
p->rear = -1;
p->maxSize = maxSize;
return p;
}

void enQueue(queue *q,int data)
{
if (q->rear == -1)
{
q->Array[++q->rear] = data;
++q->front;
}
else
{
if ((q->rear + 1) % q->maxSize == 0)//rear到达了数组结尾
{
if (q->front > 0)//数组头位置已经没有数据
{
q->rear = 0;
q->Array[q->rear] = data;
}
else//还有数据
{
std::cout << "栈已满，无法入栈" << std::endl;
return;
}
}
else if (q->rear == q->front-1)//如果已经到了头游标的前一个位置，就是再添加也没有位置了
{
std::cout << "栈已满，无法入栈" << std::endl;
return;
}
else//排除了以上两种情况后，就可以随便插入了
{
q->Array[++q->rear] = data;
}
}
}

void deQueue(queue *q)
{
if (q->front == -1)
{
std::cout << "队列为空" << std::endl;
return;
}
else
{
if ((q->front+1)%q->maxSize==0)//如果front标在结尾
{
if (q->front == q->rear)
{
q->front = q->rear = -1;
}
else
{
q->front = 0;
}
}
else
{
if (q->front == q->rear)
{
q->front = q->rear = -1;
}
else
{
++q->front;
}
}
}
}

int head(queue *q)
{
if (q->front == -1)
{
std::cout << "队列为空,返回 ";
return -1;
}
return q->Array[q->front];
}

int main(void)
{
queue *q = createQueue(5);
enQueue(q, 1);
enQueue(q, 2);
enQueue(q, 3);
enQueue(q, 4);
enQueue(q, 5);
enQueue(q, 6);
deQueue(q);
deQueue(q);
deQueue(q);
enQueue(q, 123);
enQueue(q, 234);
std::cout << head(q) << std::endl;
system("pause");
return 0;
}

测试不是太过严格，如果读者发现问题，希望不吝赐教，不胜感激。

以上。