双端队列（数据结构作业第七周的一道题目）

6-2 双端队列 (25 分)

双端队列（deque，即double-ended queue的缩写）是一种具有队列和栈性质的数据结构，即可以（也只能）在线性表的两端进行插入和删除。若以顺序存储方式实现双端队列，请编写例程实现下列操作：

Push(X,D)：将元素X插入到双端队列D的头；
Pop(D)：删除双端队列D的头元素，并返回；
Inject(X,D)：将元素X插入到双端队列D的尾部；
Eject(D)：删除双端队列D的尾部元素，并返回。
函数接口定义：

bool Push( ElementType X, Deque D );
ElementType Pop( Deque D );
bool Inject( ElementType X, Deque D );
ElementType Eject( Deque D );

其中Deque结构定义如下：

typedef int Position;
typedef struct QNode *PtrToQNode;
struct QNode {
    ElementType *Data;      /* 存储元素的数组   */
    Position Front, Rear;   /* 队列的头、尾指针 */
    int MaxSize;            /* 队列最大容量     */
};
typedef PtrToQNode Deque; 

注意：Push和Inject应该在正常执行完操作后返回true，或者在出现非正常情况时返回false。当Front和Rear相等时队列为空，Pop和Eject必须返回由裁判程序定义的ERROR。

裁判测试程序样例：

#include 
#include 

#define ERROR -1
typedef int ElementType;
typedef enum { push, pop, inject, eject, end } Operation;
typedef enum { false, true } bool;
typedef int Position;
typedef struct QNode *PtrToQNode;
struct QNode {
    ElementType *Data;      /* 存储元素的数组   */
    Position Front, Rear;   /* 队列的头、尾指针 */
    int MaxSize;            /* 队列最大容量     */
};
typedef PtrToQNode Deque; 

Deque CreateDeque( int MaxSize )
{   /* 注意：为区分空队列和满队列，需要多开辟一个空间 */
    Deque D = (Deque)malloc(sizeof(struct QNode));
    MaxSize++;
    D->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
    D->Front = D->Rear = 0;
    D->MaxSize = MaxSize;
    return D;
}

bool Push( ElementType X, Deque D );
ElementType Pop( Deque D );
bool Inject( ElementType X, Deque D );
ElementType Eject( Deque D );

Operation GetOp();          /* 裁判实现，细节不表 */
void PrintDeque( Deque D ); /* 裁判实现，细节不表 */

int main()
{
    ElementType X;
    Deque D;
    int N, done = 0;

    scanf("%d", &N);
    D = CreateDeque(N);
    while (!done) {
        switch(GetOp()) {
        case push: 
            scanf("%d", &X);
            if (!Push(X, D)) printf("Deque is Full!\n");
            break;
        case pop:
            X = Pop(D);
            if ( X==ERROR ) printf("Deque is Empty!\n");
            else printf("%d is out\n", X);
            break;
        case inject: 
            scanf("%d", &X);
            if (!Inject(X, D)) printf("Deque is Full!\n");
            break;
        case eject:
            X = Eject(D);
            if ( X==ERROR ) printf("Deque is Empty!\n");
            else printf("%d is out\n", X);
            break;
        case end:
            PrintDeque(D);
            done = 1;
            break;
        }
    }
    return 0;
}

/* 你的代码将被嵌在这里 */
输入样例：
3
Pop
Inject 1
Pop
Eject
Push 2
Push 3
Eject
Inject 4
Inject 5
Inject 6
Push 7
Pop
End
输出样例：
Deque is Empty!
1 is out
Deque is Empty!
2 is out
Deque is Full!
Deque is Full!
3 is out
Inside Deque: 4 5

我的想法

第一次碰到这个题目，真的研究了将近一个小时才把题目看懂。也第一次知道，STL里面有deque这个东西，从来没用过，以后也会尝试着使用。而这道题目就是给deque写四个子函数。
题目其实比较简单，主要是得看懂题目。如果经常使用STL的人可能十来分钟就能搞定这个题目。我的不幸是我不仅没用过STL里的deque，我甚至都不知道STL里面有这个东西，所以完全不知道deque的概念和定义，只能看着题目猜测，于是读题读了将近一个小时。

需要注意的地方

1. MaxSize的值。

Deque D = (Deque)malloc(sizeof(struct QNode));
   MaxSize++;
   D->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
   D->Front = D->Rear = 0;
   D->MaxSize = MaxSize;

这段代码要特别注意一下，用户输入了MaxSize，裁判会在创建函数中将其扩大一个，这将直接影响到判满和双端队列的容量。

2. 空出来的数组快。
   空出来的一个块，要跟着一个索引走。换句话说，Front和Rear要有一个索引指向一个空的数组成员。
   事实证明，这个空出来的一块，应该跟着Rear走。换句话说，就是Rear索引对应的数组成员应该一直是这个空值NULL，而Front索引对应的内容应该不为NULL，除非deque是空的。
   为什么呢？呵呵，我抄的别人的CSDN发现的。
   其实我第一次让Front索引一直指向NULL的，为什么呢？因为第一感觉，如果Front指向一个成员，那么计算循环的数字关系应该会很麻烦。但是这样一直WA。
   然而事实证明，NULL跟着Front亦或者是Rear，处理循环的数字关系都差不多，所以我觉得都行。但是我就是做不对。
   网上找了一篇博客看，比对我俩的区别，就是他是NULL跟着Rear，而我跟着Front。他对，我错。
   关键在这：

void PrintDeque( Deque D ); /* 裁判实现，细节不表 */

我们不知道输出函数是怎样输出的，他不给看。

卧槽，太过分了！！

所以说它输出的时候从Front开始输出，和从Front的下一个索引开始输出，就会出现以上两种情况不一样的结果，气鼓鼓。
下面是AC代码：

bool Push( ElementType X, Deque D ){
    if((D->Rear+1)%(D->MaxSize)==D->Front)
    return false;
    else{
        if(D->Front==0){
            D->Front=(D->MaxSize)-1;
            D->Data[D->Front]=X;
        }
        else{
            D->Front--;
            D->Data[D->Front]=X;
        }
        return true;
    }
}

ElementType Pop( Deque D ){
    if(D->Front==D->Rear)
    return ERROR;
    else{
        ElementType a=D->Data[D->Front];
        D->Front=(D->Front+1)%(D->MaxSize);
        return a;
    }
}

bool Inject( ElementType X, Deque D ){
     if((D->Rear+1)%(D->MaxSize)==D->Front)
    return false;
    else{
        D->Data[D->Rear]=X;
        D->Rear=(D->Rear+1)%(D->MaxSize);
        return true;
    }
}

ElementType Eject( Deque D ){
    if(D->Front==D->Rear)
    return ERROR;
    else{
        
        if(D->Rear==0)
        D->Rear=D->MaxSize-1;
        else
        D->Rear--;
        ElementType a=D->Data[D->Rear];
        return a;
    }
}