用C ++中的Stack和Queue類鏈接雙鏈表

Question

所以我有一個作業，我需要創建一個雙向鏈表，然后創建一個堆棧和隊列類，並從linkedlist類繼承以創建一個RPN calculator 。 到目前為止，我已經創建了我的雙重鏈表類，另一個創建了類。 但是，我在理解如何繼承和使用鏈接列表類以及堆棧和隊列時遇到了麻煩。 我將提供到目前為止的內容。

我去補習了，沒有太多幫助，所以我想我會尋求一些額外的幫助，不想為我做功課，而只是向正確的方向指出。

堆棧

using std::iterator;
using std::vector;
using std::string;

template<class T>
class Stack : public vector<T>
{
private:
    T getElement(bool erase);
    typename std::vector<T> ::iterator pEnd;
    T top;

public:
    Stack();
    T pop();
    T peek();
    void push(T elem);
};



template<class T>
Stack<T>::Stack()
{

}

template<class T>
void Stack<T>::push(T elem)
{
    this->push_back(elem);

}

template<class T>
T Stack<T>::peek()
{
    return this->getElement(false);
}

template<class T>
T Stack<T>::pop()
{
    return this->getElement(true);
}

template<class T>
T Stack<T>::getElement(bool erase)
{
    this->pEnd = this->end() - 1;
    T tmp;
    if (this->size() > 0)
    {
        tmp = *this->pEnd;
        if (erase) {
            this->erase(pEnd);
        }
    }

    return tmp;

}

隊列

using namespace std;

class Queue
{

private:
    int items[MAXQUEUE];
    int head;
    int tail;

public:
    Queue();
    bool isEmpty();
    bool isFull();
    bool enqueue(int item);
    int dequeue();
    int peek();
};



Queue::Queue()
    :head(QEMPTY), tail(QEMPTY)
{

}

bool Queue::isEmpty()
{
    return this->head == this->tail;

}

bool Queue::isFull()
{

    return this->tail == MAXQUEUE;
}

bool Queue::enqueue(int item)
{
    if (this->isFull())
        return false;

    this->items[this->tail] = item;
    tail = (tail + 1) % MAXQUEUE;
    return true;

}

int Queue::dequeue()
{
    if (this->isEmpty())
        return EMPTY;

    int item = this->items[head];
    this->head = (this->head + 1) % MAXQUEUE;
    return item;
}

int Queue::peek() {

    return this->tail;
}

雙鏈表

 using std::iterator;
using std::vector;
using std::string;



/*START OF NODE CLASS*/
/*---------------------------------------------*/
template<class T>
struct Node
{

    T Data;
    T Search;
    T value;
    Node<T>*Next;
    Node<T>*Prev;
};


template<class T>
class LinkedList
{
private:
    Node<T> *Head;
public:
    LinkedList();
    void addNode(T Data);
    void deleteNode(T Search);
    void insert(T Search, T value);
    void printListBackwards();
    void printListForwards();
};
template<class T>
LinkedList<T>::LinkedList()
{
    this->Head = NULL;

}

template<class T>
void LinkedList<T>::addNode(T data)
{

    if (Head == NULL)
    {
        Head = new Node<T>;
        Head->Data = data;
        Head->Next = NULL;
        Head->Prev = NULL;

    }
    else
    {
        Node<T>*p = this->Head;


        while (p->Next != NULL)

            p = p->Next;

        Node<T>*n = new Node<T>;
        n->Data = data;
        n->Next = NULL;
        p->Next = n;
        n->Prev = p;
    }


}

template<class T>
void LinkedList<T>::insert(T Search, T value)
{

    Node *p = Head;
    while (p->Data != Search)
    {
        p = p->Next;
    }

    Node *n = new Node;
    n->Data = value;
    n->Next = p->Next;
    p->Next = n;

}

template<class T>
void LinkedList<T>::deleteNode(T Search)
{
    Node *p = Head;
    while (p->Next->Data != Search)
    {
        p = p->Next;
    }

    Node *delPtr = p->Next;
    p->Next = p->Next->Next;

    delete delPtr;
}

template<class T>
void LinkedList<T>::printListBackwards()
{
    Node<T> *p = Head;

    while (p->Next != NULL)
    {

        p = p->Next;
    }
    while (p != NULL)
    {
        cout << p->Data<< endl;
        p = p->Prev;
    }
}

template<class T>
void LinkedList<T>::printListForwards()
{

    Node<T> *p = Head;
    while (p != NULL)
    {
        cout << p->Data << endl;
        p = p->Next;
    }
}

Answer 1

可以在頭或尾添加雙向鏈表，然后在尾刪除。

堆棧在一端（頭？）推出，並在同一端（頭）彈出。

隊列在一端（尾部）推送，在另一端（頭部）彈出。