队列实现

const int N = 1e5 + 10;
int q[N], h, t;

void push(int data) {
    q[++t] = data;
}
void pop() {
    ++h;
}

int front() {
    return q[h + 1];
}
int back() {
    return q[t];
}

bool empty() {
    return h == t;
}
int size() {
    return t - h;
}

typedef int data_type;
typedef struct {
    // 本质是一个访问受限的动态顺序表
    data_type* pdata;
    int size;
    int capacity;
} queue;

static void check_capacity(queue* ptr) {
    assert(ptr);

    if (ptr->capacity == ptr->size) {
        int newcapacity = (ptr->capacity == 0) ? 4 : ptr->capacity * 2; // 每次增容两倍
        data_type* ptmp = (data_type*)realloc(ptr->pdata, newcapacity * sizeof(data_type));
        if (ptmp == NULL)
            exit(0);
        else {
            ptr->pdata = ptmp;
            ptr->capacity = newcapacity;
        }
    }
}

queue* init() {
    queue* ret = (queue*)malloc(sizeof(queue));
    if (ret == NULL)
        exit(0);

    ret->pdata = NULL;
    ret->size = 0;
    ret->capacity = 0;
    return ret;
}

void destory(queue* ptr) {
    assert(ptr && ptr->pdata);

    free(ptr->pdata);
    free(ptr);
}

void push(queue* ptr, data_type data) {
    check_capacity(ptr);

    int i = 0;
    for (i = ptr->size; i >= 1; i--)
        ptr->pdata[i + 1] = ptr->pdata[i];
    ptr->pdata[1] = data;
    ptr->size++;
}

void pop(queue* ptr) {
    ptr->size--;
}

bool empty(queue* ptr) {
    return ptr->size == 0;
}

int size(queue* ptr) {
    return ptr->size;
}

int front(queue* ptr) {
    return ptr->pdata[ptr->size];
}

int back(queue* ptr) {
    return ptr->pdata[1];
}