数据结构：双端队列

#数据结构定义：

#define DataType int
#define maxn 10005//数组不能有负数下标，所以实际长度位maxn的两倍
struct queue{
DataType data[maxn<<1];maxn*2
int head,tail;//tail-head==1为空
}

#队首入队

void QueueEnqueueFront(struct Queue *que, DataType dt){
--que->head;
que->data[que->head]=dt;
}

#队尾入队

void QueueEnqueueRear(struct Queue *que, DataType dt){
que->tail++;
que->data[que->tail]=dt;
}

#队首出队

void QueueDequeueFront(struct Queue* que){
que->head++;
}

#队尾出队

void QueueDequeueRear(struct Queue* que){
que->tail--;
}

#清空队列

void QueueClear(struct Queue* que){
que->head=maxn;
que->tail=que->head-1;
}

#只读接口包含：获取队首元素、获取队尾元素、获取队列大小、队列的判空，实现如下：

DataType QueueGetFront(struct Queue *que){
return que->data[que->head];
}
DataType QueueGetRear(struct Queue *que){
return que->data[que->tail];
}
int QueueGetSize(struct Queue *que){
return que->tail-que->head+1;
}
int QueueIsEmpty(struct Queue *que){
return !QueueGetSize(que);
}

#双端队列的链表实现

#define DataType int
Struct QueueNode;
struct QueueNode{
DataType data;
struct QueueNode *prev;
struct QueueNode *next; 
}
struct queue{
struct QueueNode *tail,*head;
int size;
}

#创建节点

struct QueueNode *QueueCreateNode(DataType dt){
struct QueueNode *vtx=(struct QueueNode*)malloc(sizeof(struct QueueNode));
vtx->data=dt;
vtx->next=vtx->prev=null;
return vtx;
}

#入队操作

void _QueueEnqueue(struct Queue *que, DataType dt, int isFrontOrRear) {
struct QueueNode *vtx=QueueCreatNode(dt);
if(que->size==0){
que->head=que->tail=vtx;
else{
if(isFrontOrRear){
vtx->next=que->head;
que->head->prev=vtx;
que->head=vtx;
}else{
que->tail->next = vtx;             
vtx->prev = que->tail;
que->tail = vtx;                   
}
}
}
++que->size;
}

#出队操作

void _QueueDequeue(struct Queue *que, struct QueueNode *temp, int isFrontOrRear) {
if(que->size == 1) {
que->head = que->tail = NULL;     
}else {
if(isFrontOrRear) {               
que->head = temp->next;        
que->head->prev = NULL;
}else {
que->tail = temp->prev;       
que->tail->next = NULL;
}        
}
free(temp);                           
--que->size;                           
}

#只读接口包含：获取队首元素、获取队尾元素、获取队列大小、队列的判空

DataType QueueGetFront(struct Queue* que) {
return que->head->data;              
}
DataType QueueGetRear(struct Queue* que) {
return que->tail->data;             
}
int QueueGetSize(struct Queue* que) {
return que->size;                    
}
int QueueIsEmpty(struct Queue* que) {
return !QueueGetSize(que);
}