循環隊列-雙端和單端

單循環隊列

• q ：用數組來記錄數據

• cap：表明數組的長度

• len：表明元素的個數，取尾部元素能夠根據頭元素指針和這個值來進行計算

  (queue->head+queue->len)%queue->cap ，

  取餘是爲了在規定範圍內循環使用有限空間

• head：頭元素的指針

---

• 出隊：出頭元素只須要將head往前移動便可，注意也要取餘， 同時len須要減一

• 入隊：入隊只須要賦值給 (queue->head+queue->len)%queue->cap位置的值便可，同時 len++，也就是說 tail=(queue->head+queue->len)%queue->cap) 永遠指向尾部元素的後一個待賦值的位置

#include <iostream>
using namespace std;

struct  Queue{
	
	int* q;
	int cap;
	int len;
	int head;
};

Queue* Create(int cap){
	Queue* queue = (Queue*)malloc(sizeof(Queue));
	queue->q = (int*)calloc(cap,sizeof(int));
	queue->len=0;
	queue->cap=cap;
	queue->head=0;
	return queue;
}

bool isFull(Queue* queue){
	return queue->cap==queue->len; 
}
bool isEmpty(Queue* queue){
	return queue->len==0;
}

bool enQueue(Queue* queue,int val){
	 if(isFull(queue))
	 	return false;
	 
	 queue->q[(queue->head+queue->len)%queue->cap] = val;
	 
	 queue->len++;
	 
	 return true;	 
}
int deQueue(Queue* queue){
	if(isEmpty(queue))
		return -1;
	int r = queue->q[queue->head];
	queue->head = (queue->head+1)%queue->cap;
	queue->len--;
	return r;
}

int Front(Queue* queue){
	if(isEmpty(queue))
		return -1;
	return queue->q[queue->head] ;	
}
int Rear(Queue* queue){
	if(isEmpty(queue))
		return -1;
	return queue->q[(queue->head+queue->len-1)%queue->cap];
}



int main(int argc, char *argv[])
{
	Queue* queue = Create(4);
	enQueue(queue,1);
 	enQueue(queue,2);
 	enQueue(queue,3);
 	cout<<enQueue(queue,4)<<endl;
 	cout<<enQueue(queue,5)<<endl;
 	
 	cout<<"----------------\n";
 	
 	cout<<deQueue(queue)<<endl; 
 	cout<<deQueue(queue)<<endl; 
 	cout<<Rear(queue)<<"  "<<Front(queue)<<endl; 
 	
 	
 	
	return 0;
}

---

雙端循環隊列

• head：指向頭元素指針
• tail：指向尾部元素的後一個待賦值的位置
• q：數據數組指針
• length：元素個數
• N：數組容量， 比設定的容量大一

爲何N不設置爲cap，由於須要留一個位置判斷隊滿

---

• 左入：head永遠指向左邊的頭元素，head向左移動，(queue->head-1+queue->N)%queue->N ，而後賦值。+N是爲了防止出席那負數

• 左出：head向右移動，(queue->head+1+queue->N)%queue->N，

• 右入：賦值 而後tail向右移動， (queue->tail+1+queue->N)%queue->N，爲何tail先賦值，由於tail永遠指向右邊尾元素的下一個待賦值的元素的位置。

• 右出：tail向左移動，(queue->tail-1+queue->N)%queue->N;

• 判滿：由於開闢隊列的時候多留了一個位置，因此若是 ((queue->tail+1)%queue->N)==queue->head，則隊列滿了

• 判空：由於剛開始 tail=head=0，因此是空的，若是在移動的過程當中出現空了，也就是說 head追上了tail的位置，就表明隊列空了

#include <iostream>
#include <limits.h> 
using namespace std;
#define SIZE 5
struct Dequeue{
	int head;
	int tail;
	int N;  //爲啥多一個 由於%運算以後能達到SIZE。 好比4 那麼只能到3 
	int* q;
	int length;	
};

Dequeue* Create(int k){
	Dequeue* queue = (Dequeue*)malloc(sizeof(Dequeue));
	queue->head=0;
	queue->tail=0;
	queue->length=0;
	queue->q = (int*)calloc(queue->N,sizeof(int));
	queue->N = k+1;
	return queue;
}

bool isEmpty(Dequeue* queue){
	return queue->head==queue->tail;
}
bool isFull(Dequeue* queue){
	return ((queue->tail+1)%queue->N)==queue->head;
}


bool Lpush(Dequeue* queue,int val){
	if(isFull(queue))
		return false;
	
	queue->head = (queue->head-1+queue->N)%queue->N;
	queue->q[queue->head] = val;
	return true;
}


bool Rpush(Dequeue* queue,int val){
	if(isFull(queue))
		return false;
		
	
	queue->q[queue->tail] = val;
	queue->tail = (queue->tail+1+queue->N)%queue->N;
	return true;
}




int Lpop(Dequeue* queue){
	if(isEmpty(queue))
		return -1;
	int r = queue->q[queue->head];
	queue->head = (queue->head+1+queue->N)%queue->N;
	return r;
}



int Rpop(Dequeue* queue){
	if(isEmpty(queue))
		return -1;
	queue->tail = (queue->tail-1+queue->N)%queue->N;	
	return queue->q[queue->tail];
}


int getFront(Dequeue* queue){
	if(isEmpty(queue))
		return -1;	
	return queue->q[queue->head];
}

int getRear(Dequeue* queue){
	if(isEmpty(queue))
		return -1;
	return queue->q[(queue->tail-1+queue->N)%queue->N];			
}



int main(int argc, char *argv[])
{
	Dequeue* q = Create(4);
	Lpush(q,1);
	Lpush(q,2);
	Rpush(q,3);
	Rpush(q,4);

	cout<<Lpop(q)<<endl;
	cout<<Rpop(q)<<endl;
	cout<<Lpop(q)<<endl;
	cout<<Rpop(q)<<endl;
	return 0;
}