实现循环队列的入队，出队，求队列长度

循环队列是一种特殊的线性表，它的两端可以互相连接形成一个环形结构。在循环队列中，当队列满时，新的元素会插入到队列头部，而最后一个元素之后的位置将成为新的头节点；同样，当队列为空试图从尾部删除元素时，会从头部开始。

**入队操作 (enqueue):**
1. 首先，检查队列是否已满。如果队列未满（即 rear 指针 < front），将新元素添加到 rear 指向的位置。
2. 如果队列已满，则更新 rear 指针，使其指向下一个可用位置（front + 1）。如果 rear 到达数组的末尾并加 1 后等于 front（表示队列满了又绕回了开头），则需要扩展队列容量。
3. 扩展队列时，通常是在原数组的末尾追加新的元素，并更新 rear 指针指向新添加的位置。

**出队操作 (dequeue):**
1. 检查队列是否为空。如果队列非空（即 front 指针不是数组的第一个元素），则返回 front 指向的元素。
2. 更新 front 指针，使其指向 next front（front+1），如果 front 已经到达数组的末尾并加 1 后等于 rear （队列空），那么需要调整状态处理这种情况。

**求队列长度 (get queue length):**
1. 如果 front 等于 rear，说明队列为空，长度为 0。
2. 否则，长度就是 rear 和 front 的差值（两者相减取模数组长度，避免溢出），加上 1，因为循环队列还包括 front 节点。

循环队列的伪代码示例：

class CircularQueue:
    def __init__(self, capacity):
        self.capacity = capacity
        self.front = 0
        self.rear = -1
        self.queue = [None] * capacity

    # Enqueue operation
    def enqueue(self, data):
        if (self.rear + 1) % self.capacity == self.front:
            self._resize()
        self.queue[(self.rear + 1) % self.capacity] = data
        self.rear = (self.rear + 1) % self.capacity

    # Dequeue operation
    def dequeue(self):
        if self.is_empty():
            return None
        removed_data = self.queue[self.front]
        if self.front == self.rear:
            self._shrink()
        else:
            self.front = (self.front + 1) % self.capacity
        return removed_data

    # Get queue length
    def get_length(self):
        if self.is_empty():
            return 0
        else:
            return (self.rear - self.front + 1) % self.capacity  # or just return self.rear - self.front if front <= rear

    # Helper functions to resize and shrink the queue
    def _resize(self):
        new_capacity = self.capacity * 2
        new_queue = [None] * new_capacity
        for i in range(self.front, self.rear + 1):
            new_queue[i] = self.queue[(i + 1) % self.capacity]
        self.front = 0
        self.rear = len(new_queue) - 1
        self.queue = new_queue

    def _shrink(self):
        if self.capacity // 2 > 1:
            self.capacity //= 2
            new_queue = [None] * self.capacity
            for i in range(self.front, self.rear + 1):
                new_queue[i % self.capacity] = self.queue[i]
            self.front = 0
            self.rear = self.capacity - 1
            self.queue = new_queue