6 队列

顺序队列

• 采用数组存储的方式，规定只能从一段插入，从另一段删除元素。

• 特点：会出现“假溢出”的现象。

数据结构及操作：

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

bool IsEmpty(SqQueue q) {
	if (q.rear == q.front) return true;
	return false;
}

bool EnQueue(SqQueue &q, int x) {
	if (q.rear == MaxSize - 1) return false;
	q.data[q.rear++] = x;
	return true;
}

bool DeQueue(SqQueue &q,int &e) {
	if (IsEmpty(q)) return false;
	e = q.data[q.front++];
	return true;
}

需要注意：

• 队空：q.rear == q.front
• 队满：q.rear == MaxSize -1
• 队头指针指向队头元素，队尾指针指向队尾元素的下一个位置。

循环队列

• 利用特殊的算法，将顺序队列变为循环队列。防止了“假溢出”现象的发生。

为了区分是队空还是队满的情况，有三种处理方式∶

• 1）牺牲一个单元来区分队空和队满，入队时少用一个队列单元，这是一种较为普遍的做法，
  约定以"队头指针在队尾指针的下一位置作为队满的标志"
  • 队满条件∶ （Q.rear+1）% Size == Q.front。
  • 队空条件仍∶ Q.front == Q.rear。
  • 队列中元素的个数∶（Q.rear-Q.front+MaxSize）% MaxSize。

数据结构及操作

typedef struct {
	int data[MaxSize];
	int rear, front;
}Queue;

bool IsEmpty2(SqQueue q) {
	//循环队列队空条件，重要
	if (q.rear == q.front) return true;

	return false;
}

bool EnQueue2(SqQueue &q, int x) {
	//循环队列队满条件
	if ((q.rear+1) % MaxSize == q.front ) return false;

	q.data[q.rear] = x;
	q.rear = (q.rear + 1 + MaxSize) % MaxSize;
	return true;
}

bool DeQueue2(SqQueue &q, int &e) {
	if (IsEmpty(q)) return false;
	e = q.data[q.front];
	q.front = (q.front + 1 + MaxSize) % MaxSize;
	return true;
}

• 2）类型中增设表示元素个数的数据成员。这样，队空的条件为Q.size == 0;队满的条件为Q.size == MaxSize。这两种情况都有 Q.front == Q.rear。
  数据结构及操作

typedef struct {
	int data[MaxSize];
	int rear, front;
	int size;
}Queue;

bool init(Queue &q) {
	q.rear = q.front = 0;
	q.size = 0;
}

bool isEmpty(Queue q) {
	if (q.size == 0) return true;
	return false;
}

bool enQueue(Queue &q,int x) {
	if (q.size == MaxSize) return false;

	q.data[q.rear] = x;
	q.rear = (q.rear + 1) % MaxSize;
	q.size++;
	return true;

}

bool deQueue(Queue &q, int &x) {
	if (isEmpty(q)) return false;

	x = q.data[q.front];
	q.front = (q.front + 1) % MaxSize;
	q.size--;
	return true;
}

• 3）类型中增设 tag 数据成员，以区分是队满还是队空。tag 等于0 时，若因删除导致
  Q.front == Q.rear，则为队空;tag等于1时，若因插入导致Q.front == Q.rear， 则为队满。
  数据结构及操作

typedef struct {
	int data[MaxSize];
	int rear, front;
	int tag;
}Queue;

bool init(Queue &q) {
	q.rear = q.front = 0;
	q.tag = 2;
}

bool isEmpty(Queue q) {
	if (q.tag == 1 && q.rear == q.front) return true;
	return false;
}

bool enQueue(Queue &q,int x) {
	//判断是否队满，tag = 1 && rear = front
	if (q.tag == 1 && q.rear == q.front) return false;

	q.data[q.rear] = x;
	q.rear = (q.rear + 1) % MaxSize;
	q.tag = 1;
	return true;
}

bool deQueue(Queue &q, int &x) {
	if (q.tag == 0 && q.rear == q.front) return false;

	x = q.data[q.front];
	q.front = (q.front + 1) % MaxSize;
	q.tag = 0;
	return true;
}

链队列

• 以链表为存储结构的一种队列，不会出现存储空间不足的情况；但是在存储空间的利用率上会比顺序存储的队列结构低一些，因为要存储指针需要的空间。

数据结构及操作：

typedef struct Node {
	int data;
	struct Node *next;
}Node;

typedef struct{
	Node *rear,*front;
}Queue;


void Init(Queue &q) {
	q.front  = q.rear   = (Node*)malloc(sizeof(Node));
	q.rear->next = NULL;
}


bool IsEmpty3(Queue q) {
	if (q.rear == q.front  )  return true;
	return false;
}


void EnQueue3(Queue &q,int x) {
	Node *s = (Node*)malloc(sizeof(Node));
	s->next = NULL;
	s->data = x;
	
	q.rear->next = s;
	q.rear = s;

}

bool DeQueue3(Queue &q, int &e) {
	if (IsEmpty3(q)) return false;


	Node *t = (Node*)malloc(sizeof(Node));
	t = q.front->next;
	e = t->data;
	//不能把头结点丢了
	q.front->next = t->next;
	if (q.rear == t)
		q.rear = q.front;

	free(t);
	return true;
}