#include<stdio.h>
#include<string.h>
//#include<stdlib.h>
//#include<assert.h>
//
//void fanzhuan(int* arr, int arrSize)
//{
//    int* left = arr;
//    int* right = arr + (arrSize - 1);
//    while (left < right)
//    {
//        int tmp = *left;
//        *left = *right;
//        *right = tmp;
//        left++;
//        right--;
//    }
//}
//
//
//
//int main()
//{
//    int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
//    fanzhuan(arr, 10);
//    fanzhuan(arr, 3);
//    fanzhuan(arr + 3, 10 - 3);
//	return 0;
//}


#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
#include<stdio.h>
//
//typedef struct Queuenode {
//    int data;
//    struct Queuenode* prev;
//    struct Queuenode* next;
//}Queuenode;
//
//typedef struct {
//    Queuenode* Front;
//    Queuenode* tail;
//} MyCircularQueue;
//
//bool myCircularQueueIsFull(MyCircularQueue* obj);
//bool myCircularQueueIsEmpty(MyCircularQueue* obj);
//
//
//MyCircularQueue* myCircularQueueCreate(int k) {
//    k += 1;
//    MyCircularQueue* queue = malloc(sizeof(MyCircularQueue));
//    queue->Front = queue->tail = NULL;
//
//    while (k)
//    {
//        Queuenode* newnode = (Queuenode*)malloc(sizeof(Queuenode));
//
//        if (newnode == NULL)
//        {
//            printf("myCircularQueueCreate malloc fail");
//            exit(-1);
//        }
//        newnode->next = NULL;
//        newnode->prev = NULL;
//
//
//        if (queue->Front ==  NULL)
//        {
//            queue->Front = queue->tail = newnode;
//            queue->Front->next = queue->Front;
//            queue->Front->prev = queue->Front;
//        }
//        else
//        {
//            queue->tail->next = newnode;
//            newnode->prev = queue->tail;
//            newnode->next = queue->Front;
//            queue->Front->prev = newnode;
//            queue->tail = newnode;
//        }
//
//        k--;
//    }
//    queue->tail = queue->Front;
//        return queue;
//}
//
//bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
//    if (myCircularQueueIsFull(obj))
//        return false;
//    obj->tail->data = value;
//    obj->tail = obj->tail->next;
//    return true;
//}
//
//bool myCircularQueueDeQueue(MyCircularQueue* obj) {
//    if (myCircularQueueIsEmpty(obj))
//        return false;
//    obj->Front = obj->Front->next;
//    return true;
//}
//
//int myCircularQueueFront(MyCircularQueue* obj) {
//    if (myCircularQueueIsEmpty(obj))
//        return -1;
//    return obj->Front->data;
//}
//
//int myCircularQueueRear(MyCircularQueue* obj) {
//    if (myCircularQueueIsEmpty(obj))
//        return obj->tail->prev->data;
//}
//
//bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
//    return obj->Front == obj->tail;
//}
//
//bool myCircularQueueIsFull(MyCircularQueue* obj) {
//    return obj->tail->next == obj->Front;
//}
//
//void myCircularQueueFree(MyCircularQueue* obj) {
//    Queuenode* cur = obj->Front->prev;
//    while (cur != obj->Front)
//    {
//        Queuenode* curPrev = cur->prev;
//        free(cur);
//        cur = curPrev;
//    }
//    free(cur);
//    free(obj);
//}


typedef struct {
    int* a;
    int Front;
    int Tail;
    int k;
} MyCircularQueue;

bool myCircularQueueIsFull(MyCircularQueue* obj);
bool myCircularQueueIsEmpty(MyCircularQueue* obj);


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = NULL;
    obj->Front = obj->Tail = 0;
    obj->k = k;
    int* q = (int)malloc(sizeof(int) * (k + 1));
    if (q == NULL)
    {
        printf("malloc fail");
        exit(-1);
    }
    obj->a = q;
    return obj;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (myCircularQueueIsFull(obj))
    {
        return false;
    }
    else
    {
        obj->a[obj->Tail] = value;
        obj->Tail++;
        obj->Tail %= obj->k + 1;
        return true;
    }
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        obj->Front++;
        obj->Tail %= obj->k + 1;
        return true;
    }
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[obj->Front];
    }
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        int i = (obj->Tail + obj->k) % (obj->k + 1);
        return obj->a[i];
    }
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->Front == obj->Tail;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->Tail + 1) % (obj->k + 1) == obj->Front;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}



void test1()
{
    MyCircularQueue* ps = myCircularQueueCreate(5);
    myCircularQueueEnQueue(ps, 1);
    myCircularQueueEnQueue(ps, 2);
    myCircularQueueEnQueue(ps, 3);
    myCircularQueueEnQueue(ps, 4);
    myCircularQueueEnQueue(ps, 5);
    myCircularQueueEnQueue(ps, 6);
    myCircularQueueDeQueue(ps);
    myCircularQueueDeQueue(ps);
    myCircularQueueEnQueue(ps, 5);
    myCircularQueueEnQueue(ps, 6);



    myCircularQueueFree(ps);
}


int main()
{
    test1();
    return 0;
}