排序的双链前哨列表合并功能问题

如何解决排序的双链前哨列表合并功能问题

我正在研究模板化数据结构类，该类是使用哨兵节点的双向链表。 该列表是基于insert（）排序的，并且我正在使用合并功能，其中每个列表的节点必须组合到this-> list中。节点必须移动并且不能创建新节点。并且如果两个列表中都存在相同的值，则另一个节点值必须在当前节点值之后。

我编码了我认为是逻辑的实现，但是我得到的输出不符合预期，结果对我来说也没有意义，因此如果有人可以解释我如何获得结果，将不胜感激。

类定义

class SortedList {
    struct Node {
        T data_;
        Node* next_;
        Node* prev_;
        Node(const T& data = T{},Node* nx = nullptr,Node* pr = nullptr) {
            data_ = data;
            next_ = nx;
            prev_ = pr;
        }
    };
    Node* front_;
    Node* back_;

public:
    class const_iterator {
        friend class SortedList;
        Node* current_;
        const_iterator(Node* n)
        {
            current_ = n;
        }
    public:
        const_iterator() {
            //Set to safe state         
            current_ = nullptr;
        }
        const_iterator& operator++() {
            current_ = current_->next_;
            return *this;
        }
        const_iterator operator++(int) {
            const_iterator old = *this;
            current_ = current_->next_;
            return old;
        }
        const_iterator& operator--() {
            current_ = current_->prev_;
            return *this;
        }
        const_iterator operator--(int) {
            const_iterator old = *this;
            current_ = current_->prev_;
            return old;
        }
        bool operator==(const_iterator rhs) {
            return (current_ == rhs.current_) ? true : false;
        }
        bool operator!=(const_iterator rhs) {
            return !(*this == rhs);
        }
        bool operator>(const_iterator rhs) {
            return current_->data_ > rhs->current_->data_;
        }
        const T& operator*()const {
            return current_->data_;
        }
    };
    class iterator :public const_iterator {
        friend SortedList;
        iterator(Node* n) :const_iterator(n) {};
    public:
        iterator() : const_iterator() {};
        //prefix
        iterator& operator++() {
            this->current_ = this->current_->next_;
            return *this;
        }
        //post-fix
        iterator operator++(int) {
            iterator old = *this;
            this->current_ = this->current_->next_;
            return old;
        }
        iterator& operator--() {
            this->current_ = this->current_->prev_;
            return *this;
        }
        iterator operator--(int) {
            iterator old = *this;
            this->current_ = this->current_->prev_;
            return old;
        }
        T& operator*() {
            return this->current_->data_;
        }
        const T& operator*()const {
            return this->current_->data;
        }
    };
    SortedList();                                   //done
    ~SortedList();
    SortedList(const SortedList& rhs);
    SortedList& operator=(const SortedList& rhs);
    SortedList(SortedList&& rhs);
    SortedList& operator=(SortedList&& rhs);
    iterator begin() {
        return iterator(front_->next_);
    }
    iterator end() {
        return iterator(back_);
    }
    const_iterator cbegin() const {
        return const_iterator(front_->next_);
    }
    const_iterator cend() const {
        return const_iterator(back_);
    }
    iterator insert(const T& data);
    iterator search(const T& data);
    const_iterator search(const T& data) const;
    iterator erase(iterator it);
    void merge(SortedList& other);
    bool empty() const;
    int size() const;
};

合并功能

template <typename T>
void SortedList<T>::merge(SortedList& other) {
    
    iterator it = this->begin();
    iterator oit = other.begin();
    while (oit !=  other.end()) {               
        std::cout << *oit << " " << *it << std::endl;
        if (*oit < *it) {
            oit.current_->prev_->next_ = oit.current_->next_;
            oit.current_->next_->prev_ = oit.current_->prev_;
            oit.current_->next_ = it.current_;
            oit.current_->prev_ = it.current_->prev_;
            it.current_->next_ = oit.current_;
        }
        else {
            oit.current_->prev_->next_ = oit.current_->next_;
            oit.current_->next_->prev_ = oit.current_->prev_;
            oit.current_->next_ = it.current_->next_;
            oit.current_->prev_ = it.current_;
            it.current_->prev_ = oit.current_;
        }
        oit++;
        it++;
    }
}

主测试器

int main() {
    int num[] = { 3,5,1,2,6,8,9,11 };
    int num2[] = { 1,4,12,7,9 };

    SortedList<int> l;
    SortedList<int> l2;
    for (int i = 0; i < 8; i++)
    {
        l.insert(num[i]);
        l2.insert(num2[i]);
    }
     SortedList<int>::iterator result;
     SortedList<int>::iterator result2 = l2.begin();
     result = l.begin();
     while (result != l.end()) {
         std::cout << *result << "    " << *result2 << std::endl;
         ++result;
         ++result2;
     }
     l.merge(l2);

输出

1    1
2    4
3    5
5    6
6    7
8    8
9    9
11    12

1 1
2 2
3 3
5 5
6 6
8 8
9 9
11 11
0 0

我不明白为什么我的第二个输出为* it和* oit显示相同的值，我很确定错误是我如何分配oit.current _-> next＆prev，但是我不确定。

任何见解都适用。