數組和鏈表實現隊列

數組和鏈表實現隊列

#include <iostream>
using namespace std;

//抽象類
class Queue {
public:
    virtual bool enqueue(int value) = 0;
    virtual bool deququq(int &value) = 0;
    virtual bool isEmpty() = 0;
    virtual int size() = 0;
};

class ArrayQueue : public Queue {
    int *data;
    int head, tail, capcity;
    int add(int pos) {
        return (pos + 1) % (capcity + 1);
    }
    bool isFull() {
        return head == tail;
    }
public:
    explicit ArrayQueue(int capcity) : head(0), tail(1), capcity(capcity) {
        data = new int[capcity + 1];
    }

    ~ArrayQueue() {
        delete[] data;
    }

    ArrayQueue(const ArrayQueue&) = delete;
    ArrayQueue& operator=(const ArrayQueue&) = delete;

    bool enqueue(int value) override {
        if (isFull())
            return false;
        data[tail] = value;
        tail = add(tail);
        return true;
    }

    bool deququq(int &value) override {
        if (isEmpty())
            return false;
        head = add(head);
        value = data[head];
        return true;
    }

    bool isEmpty() override {
        return add(head) == tail;
    }

    int size() override {
        int res = tail - add(head);
        return res >= 0 ? res : res + capcity + 1;
    }
};

class Node {
public:
    int value;
    Node *next;
};

class ListQueue : public Queue {
    Node *head;
    Node *tail;
    int count;
public:
    ListQueue() : head(nullptr), tail(nullptr), count(0) {}

    ~ListQueue() {
        while (head) {
            Node *cur = head;
            head = head->next;
            delete cur;
        }
    }

    ListQueue(const ListQueue&) = delete;
    ListQueue &operator=(const ListQueue&) = delete;

    bool enqueue(int value) override {
        Node *oldTail = tail;

        tail = new Node;
        tail->value = value;
        tail->next = nullptr;

        if (isEmpty())
            head = tail;
        else
            oldTail->next = tail;

        ++count;
        return true;
    }

    bool deququq(int &value) override {
        if (isEmpty())
            return false;

        Node *cur = head;
        value = cur->value;

        head = head->next;
        if (isEmpty())
            tail = nullptr;

        --count;
        delete cur;
        return true;
    }

    bool isEmpty() override {
        return head == nullptr;
    }

    int size() override {
        return count;
    }
};

bool test(Queue &queue, const int len) {
    int a[len];
    for (int i = 0; i < len; ++i)
        a[i] = i;

    for (int j = 0; j < 10; ++j) {
        if (!queue.isEmpty()) {
            cout << __LINE__ << " should empty but not" << endl;
            return false;
        }

        for (int i = 0; i < len; ++i) {
            if (!queue.enqueue(a[i])) {
                cout << __LINE__ << " enqueue failed" << endl;
                return false;
            }
            if (i + 1 != queue.size()) {
                cout << __LINE__ << " size = " << queue.size() << ", but expect " << i + 1 << endl;
                return false;
            }
        }

        int value;
        for (int i = 0; i < len; ++i) {
            if (!queue.deququq(value)) {
                cout << __LINE__ << " dequeue failed" << endl;
                return false;
            }
            if (queue.size() + i + 1 != len) {
                cout << __LINE__ << " size = " << queue.size() << ", but expect " << len - i - 1 << endl;
                return false;
            }
            if (value != i) {
                cout << __LINE__ << " value = " << value << ", but expect " << i << endl;
                return false;
            }
        }

        if (queue.deququq(value)) {
            cout << __LINE__ << " empty queue but dequeue success" << endl;
            return false;
        }
    }

    return true;
}

int main() {
    ArrayQueue arrayQueue(10);
    ListQueue listQueue;
    cout << boolalpha << test(arrayQueue, 7) << endl;
    cout << boolalpha << test(listQueue, 7) << endl;
    return 0;
}