《数据结构与算法分析》习题-----第二章（3）（关于list的题目）

PS：这两条习题是添加到STL的List代码实现

http://www.cnblogs.com/alan-forever/archive/2012/09/12/2682437.html

3.15 给List类添加splice操作。

void splice（ iterator position， List<Object> & lst )

删除lst中的所有项，并将这些List * this中的位置position之前。lst和*this必须是不同的表，所写的例程必须是常量时间的。

PS：刚开始以为O（n）是常量，最后我发现我严重的错了，之前还想逐个逐个调用inset函数，好吧，我错了。

    void splice( iterator position, List<Object> & lst )
    {
        Node *p = position.current;

        p->prev->next = lst.head->next;
        lst.head->next->prev = p->prev;
        lst.tail->prev->next = p;
        p->prev = lst.tail->prev;

        theSize += lst.size();

        lst.init();
    }

 

3.16，给STL List类实现添加逆向迭代器。定义reverse_iterator 和const_reverse_iterator。添加方法rbegin和rend，来分别返回逆向迭代器所指向末尾标记前的项的位置和表头结点的位置，逆向迭代器在内部逆转++和--操作的意义，应该可以使用下面的代码逆向打印链表。

List<int>::reverse_iterator itr1 = l1.rbegin();
while( itr1 != l1.rend() )
cout << *itr1++ <<" ";
cout << endl;

PS：代码里面的注释有点不正确，只是含糊解释。

PS：下图有助于理解迭代器！！！！

 

 

下面的代码是逆向迭代器类的定义。

    class const_reverse_iterator
    {
    public:
        const_reverse_iterator( ) : current( NULL ) { }

        const Object & operator* ( ) const
        {
            return retrieve( );
        }

        const_reverse_iterator & operator++ ( )
        {
            current = current->prev;
            return * this;
        }

        const_reverse_iterator  operator++ ( int )
        {
            const_reverse_iterator old = *this;
            ++( *this );
            return old;
        }

        const_reverse_iterator & operator--  ( )
        {
            current = current->next;
            return * this;
        }

        const_reverse_iterator  operator-- ( int )
        {
            const_reverse_iterator old = *this;
            ++( *this );
            return old;
        }

        bool operator== ( const const_reverse_iterator & rhs ) const
        {
            return current == rhs.current;
        }

        bool operator!= ( const const_reverse_iterator & rhs ) const
        {
            return !( *this == rhs );
        }

    private:
        Node * current;

        Object & retrieve( ) const
        {
            return current->data;
        }

        const_reverse_iterator( Node * p ) : current( p ) { }

        friend class List<Object>;
    };
    //逆向迭代器

    class reverse_iterator
    {
    public:
        reverse_iterator( ) : current( NULL ) { }

        const Object & operator* ( ) const
        {
            return retrieve( );
        }

        reverse_iterator & operator++ ( )
        {
            current = current->prev;
            return * this;
        }

        reverse_iterator  operator++ ( int )
        {
            reverse_iterator old = *this;
            ++( *this );
            return old;
        }

        const_reverse_iterator & operator--  ( )
        {
            current = current->next;
            return * this;
        }

        reverse_iterator  operator-- ( int )
        {
            const_reverse_iterator old = *this;
            --( *this );
            return old;
        }

        bool operator== ( const reverse_iterator & rhs ) const
        {
            return current == rhs.current;
        }

        bool operator!= ( const reverse_iterator & rhs ) const
        {
            return !( *this == rhs );
        }

    private:
        Node * current;

        Object & retrieve( ) const
        {
            return current->data;
        }

        reverse_iterator( Node * p ) : current( p ) { }

        friend class List<Object>;
    };

下面代码是返回特殊位置的迭代器

reverse_iterator rbegin( )
    {
        return reverse_iterator( tail->prev );
    }
    const_reverse_iterator rbegin( ) const
    {
        return const_reverse_iterator( tail->prev );
    }
    //逆向begin迭代器，返回tail的前一个迭代器。
    
    reverse_iterator rend( )
    {
        return reverse_iterator( head );
    }
    const_reverse_iterator rend( ) const
    {
        return const_reverse_iterator( head );
    }
    //逆向end迭代器，返回head节点的迭代器。