双向链表

代码示例：

#include <iostream>

using namespace std;

template <typename T>
class DualLinkList
{
private:
    struct Node
    {
        T valve;
        Node* pre;
        Node* next;
    };

    //头节点
    Node m_header;
    int m_length;
    
    //定义一个有标使它指向当前元素
    Node* m_current;
    //记录每次移动的步数
    int m_step;
    
    //功能函数定位带第i个位置的前驱节点
    Node* position(int i)
    {
        Node* ret = &m_header;
        for(int p = 0; p < i; p++)
        {
            ret = ret->next;
        }
        
        return ret;
    }
    
public:
    DualLinkList()
    {
        m_header.next = NULL;
        m_header.pre = NULL;
        m_current = NULL;
        m_step = 1;
        m_length = 0;
    }
    
    //头插法
    bool insert(int i, const T& e)
    {
        bool ret = ((0 <= i) && (i <= m_length));
        
        if(ret)
        {
            Node* node = new Node();
            
            if(node != NULL)
            {
                //插入节点的前驱节点
                Node* current = position(i);
                
                //插入节点的后继节点
                Node* next = current->next;
                
                node->valve = e;
                node->next = next;
                current->next = node;
                
                //判断如果前驱节点不是头节点
                if(current != reinterpret_cast<Node*>(&m_header))
                {
                    node->pre = current;
                }
                else
                {
                    node->pre = NULL;
                }
                
                //判断如果后继节点不为空
                if(next != NULL)
                {
                    next->pre = node;
                }
                
                m_length++;
            }
            else
            {
                ret = false;
            }
        }
        else
        {
            ret = false;
        }
        
        return ret;
    }
    
    //尾插法
    bool insert(const T& e)
    {
        return insert(m_length, e);
    }
    
    //删除下标为i的元素
    bool remove(int i)
    {
        bool ret = ((0 <= i) && (i < m_length));
        
        if(ret)
        {
            //待删除节点的前驱节点
            Node* current = position(i);
            //待删除节点
            Node* toDel = current->next;
            //待删除节点的后继节点
            Node* next = toDel->next;
            
            //判断如果游标指向大删除节点则游标后移
            if(m_current == toDel)
            {
                m_current = next;
            }
            
                      
            current->next = next;
            
            //如果待删除节点的后继节点不为空则后继节点的前驱指向待删除节点的前驱
            if(next != NULL)
            {
                next->pre = toDel->pre;
            }
            
            m_length--;
            delete toDel;
        }
        else
        {
            ret = false;
        }
        
        return ret;
    }
    
    
    bool set(int i, const T& e)
    {
        bool ret = ((0 <= i) && (i < m_length));
        
        if(ret)
        {
            position(i)->next->value = e;
        }
        else
        {
            ret = false;
        }
        
        return ret;      
    }
    
    //获取下标为i的元素
    bool get(int i, T& e)
    {
        bool ret = ((0 <= i) && (i < m_length));
        
        if(ret)
        {
            e = position(i)->next->valve;
        }
        else
        {
            ret = false;
        }
        
        return ret;      
    }
    
    //这里为了便于输出重载一个get函数
    T get(int i)
    {
        T ret;
        if(get(i, ret))
        {
            return ret;
        }
        
        return ret;
    }
    
    //查找函数
    int find(const T& e)
    {
        int ret = -1;
        int i = 0;
        
        Node* node = m_header.next;
        
        while(node)
        {
            if(node->valve == e)
            {
                ret = i;
                break;
            }
            else
            {
                node = node->next;
                i++;
            }
        }
        
        return ret;
        
    }
    
    //设置游标位置和移动游标步长
    bool move(int i, int step = 1)
    {
        bool ret = ((0 <= i) && (i < m_length) && (step > 0));
        
        if(ret)
        {
            //定位到当前元素而不是前驱
            m_current = position(i)->next;
            m_step = step;
        }
        else
        {
            ret = false;
        }
        
        return ret;
    }   
    
    //获取当前游标所指的元素
    T current()
    {
        if(!end())
        {
            return m_current->valve;
        }
    }
    
    //游标后移
    bool next()
    {
        int i = 0;
        while((m_step > i) && !end())
        {
            m_current = m_current->next;
            i++;
        }
        
        return (i == m_step);
    }
    
    //游标前移
    bool pre()
    {
        int i = 0;
        while((m_step > i) && !end())
        {
            m_current = m_current->pre;
            i++;
        }
        
        return (i == m_step);
    }
    
    //终止条件
    bool end()
    {
        return (m_current == NULL);
    }
    
    int length()
    {
        return m_length;
    }
    
    void clear()
    {
        while(m_length > 0)
        {
            remove(0);
        }
    }
    
    ~DualLinkList()
    {
        clear();
    }
   
};

int main()
{
    DualLinkList<int> dl;
    
    cout << "insert()..." << endl;
    for(int i = 0; i < 5; i++)
    {
        dl.insert(0, i);
    }
    
    
    for(int i = 0; i < dl.length(); i++)
    {
        cout << dl.get(i) << endl;
    }
    
    
    cout << "find(3) = " <<  dl.find(3) << endl;
    
    cout << "move(),end(),next(),current()..." << endl;
    
    for(dl.move(0, 1); !dl.end(); dl.next())
    {
        cout << dl.current() << endl;
    }
    
    
    cout << "move(),end(),pre(),current()..." << endl;
    dl.move(dl.length() - 1);
    
    while(!dl.end())
    {
        if(dl.current() == 3)
        {
            cout << dl.current() << endl;

            dl.remove(dl.find(dl.current()));
        }
        else
        {
            dl.pre();
        }
    }
    
    
    cout << "remove(1)..." << endl;
    dl.remove(1);
    for(dl.move(0, 1); !dl.end(); dl.next())
    {
        cout << dl.current() << endl;
    }
    
        
    return 0;
}

运行截图