我當前的雙鏈列表類實現是否需要對迭代器end（）功能進行重組？

Question

恐怕我當前的雙向鏈表實現無法適當地容納迭代器。 我的迭代器end（）函數需要開始指向尾巴后的節點，以減少列表中的內容。 當然，按照我目前設計的列表，tail-> next將為null。

我是在了解我的第一個指針和尾部指針是“虛擬節點”的情況下寫的嗎？

我嘗試制作第三個指針，但是考慮到與pushBack函數非常相似，所有東西都旨在與在doublyLinkedList類中構造為nullptrs的第一個和尾部一起使用，因此我認為找不到可以實現的實現。

我一直在嘗試弄清楚如何實現額外的虛擬節點-任何解決方案都可以。

我只會顯示我認為可能相關的代碼部分。

struct node
{
    T data;
    node<T> * next;
    node<T> * prev;

    node() {
        next = nullptr;
        prev = nullptr;
    };
    node(T data, node<T> * next = nullptr, node<T> * prev = nullptr) 
        : data(data), next(next), prev(prev) {};
};

template <class T>
class LinkedList
{
private:
    node<T> * first;
    node<T> * tail;
    int size;
public:
    LinkedList();
    LinkedList(const LinkedList&);
    void copy(const LinkedList&);
    void operator=(const LinkedList&);
    //void insert_end(T dat);
    void pushBack(T data);
    void pushFront(T data);
    void display();
    void displayRev();
    int getSize();

    class Iterator
    {
    private:
        node<T> * itr;
    public:

        Iterator(node<T> * itr = nullptr) : itr(itr){};

        Iterator& operator++();
        Iterator operator++(int);
        Iterator& operator--();
        Iterator operator--(int);

        T operator*();

        bool operator!=(LinkedList<T>::Iterator other);
        bool operator==(LinkedList<T>::Iterator & other);

        ~Iterator() {}
    };
/*BEGIN AND END*/
    Iterator begin() { return Iterator(first); }
    Iterator end(tail->next) 
    {
        return Iterator(tail->next); 
    }
    ~LinkedList();
};

定義

template<class T>
typename LinkedList<T>::Iterator& LinkedList<T>::Iterator::operator--()
{

    itr = itr->prev;
    return *this;
}

template<class T>
typename LinkedList<T>::Iterator LinkedList<T>::Iterator::operator--(int)
{
    auto tmp = *this;

    itr = itr->prev;
    return tmp;
}

//constructor
template <class T>
LinkedList<T>::LinkedList()
{
    first = tail = nullptr;
    size = 0;
    /*node<T>* first = new node<T>;
    node<T>* tail = new node<T>;
    first->next = tail;
    tail->prev = first;*/

}

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

    if (first == nullptr)
    {
        first = tail = new node<T>(data);
        size++;
    }
    else
    {
        if (tail == nullptr)
        {
            tail = new node<T>(data);
            first->next = tail;
            tail->prev = first;
            size++;
        }
        else
        {
            node<T> *prevTail = tail;
            node<T> *newTail = new node<T>(data, nullptr, prevTail);
            prevTail->next = newTail;
            tail = newTail;
            size++;
        }
    }

}

主要

#include "pch.h"
#include "LinkedList.h"
#include <iostream>
typedef LinkedList<int>::Iterator iter;
int main()
{
    LinkedList<int> l1;
    l1.pushBack(10);
    l1.pushBack(20);
    l1.pushBack(30);

    for (auto itr = l1.begin(); itr != l1.end(); itr++)
    {
        std::cout << (*itr) << "  ";
    }
}

在過去的三個小時中，我一直在此工作，但無濟於事，然后又回到了我開始的地方。 如果有人能向我展示光明，我將不勝感激。

謝謝。

Answer 1

我可以看到兩個選項。 兩者都避免使用虛擬節點，盡管這也是可行的方法。

選項1：將迭代器設為僅向前的迭代器

構造結束迭代器很困難，因為自然的方法是實例化Iterator{} ，這意味着Iterator::itr節點指針將為null。 但是，在這種情況下，減量運算符將無法實現。 作為解決方案，可以刪除這些操作。

template <class T>
class LinkedList
{
    /* ... */
    class Iterator
    {
    private:
        node<T> * itr;
    public:

        Iterator(node<T> * itr = nullptr) : itr(itr){};

        Iterator& operator++();
        Iterator operator++(int);

        T operator*();

        bool operator!=(LinkedList<T>::Iterator other);
        bool operator==(LinkedList<T>::Iterator & other);
    };
    Iterator begin() { return Iterator{first}; }    
    Iterator end() { return Iterator{}; }  
};

選項2：將prev成員添加到迭代器

我認為您可以向Iterator添加prev指針以保留雙向操作。

template <class T>
class LinkedList
{
    /* ... */
    class Iterator
    {
    private:
        node<T> * current;  // null if and only if this is end iterator.
        node<T> * prev;     // may be null (at head of list)
    public:
        Iterator() : current{nullptr}, prev{nullptr} {}
        Iterator(node<T> * current) : current{current}, prev{current ? current->prev : nullptr} {}
        Iterator(node<T> * current, node<T>* prev) : current{current}, prev{prev} {}

        Iterator& operator++();    // implemented using `curr`
        Iterator operator++(int);  // implemented using `curr`
        Iterator& operator--();    // implemented using `prev`
        Iterator operator--(int);  // implemented using `prev`

        T operator*();  // implemented using `curr`

        bool operator!=(LinkedList<T>::Iterator other);
        bool operator==(LinkedList<T>::Iterator & other);
    };

    Iterator begin() { return Iterator{first}; }    
    Iterator end() { return Iterator{nullptr, tail}; }
};