双链表

双链表链表节点

ListNode.h

#include "stdafx.h"
#include <iostream>
using namespace std;

template <typename Type>class DoublyList;
template <typename Type>
//  节点信息
class ListNode{
private:
    friend  class DoublyList<Type>;
    ListNode():m_pprior(NULL),m_pnext(NULL){}
    ListNode(const Type item , ListNode<Type>*prior=NULL ,
        ListNode<Type>*next=NULL ):m_data(item),m_pprior(prior),m_pnext(next){
    }
    ~ListNode(){
        m_pnext = NULL;
        m_pprior = NULL;
    }
public:
    Type getData(){return m_data;}
private:
    Type m_data;  // 节点数据
    ListNode *m_pprior;  // 前驱
    ListNode *m_pnext;   // 后继
};

双链表链表类

DoublyList.h

#include "stdafx.h"
#include "ListNode.h"
template <typename Type>

// 双链表类 
class DoublyList{
public:
    DoublyList():head(new ListNode<Type>()){
        head->m_pnext = head;
        head->m_pprior = head;
    }
    ~DoublyList(){
        makeEmpty();
        delete head;
    }
public:
    void makeEmpty();  //  清空
    int length();   // 长度
    ListNode<Type>*find(int n =0);  // 查找第n个元素
    ListNode<Type>*findData(Type item);   // 查找元素item
    bool insert(Type item,int n=0);  // 插入一个元素 ，默认是第一个元素
    Type remove(int n =0);  // 移除第n个元素
    Type get(int n =0);  // 获取第n个元素
    void print();   // 打印双链表
private:
    ListNode<Type> *head;
};
template <typename Type>
void DoublyList<Type>::makeEmpty(){
    ListNode<Type>*pmove = head->m_pnext,*pdel;
    while(pmove!=head){
        pdel = pmove;
        pmove = pmove->m_pnext;
        delete pdel;
    }
    head->m_pnext = head;
    head->m_pprior = head;
}
template <typename Type>
int DoublyList<Type>::length(){
    ListNode<Type> *pmove = head->m_pnext;
    int count = 0;
    while(pmove!=head){
        count ++;
        pmove = pmove->m_pnext;
    }

    /*ListNode<Type>*pprior = head->m_pprior;
    ListNode<Type>*pnext = head->m_pnext;
    while(1){
        if(pprior->m_pnext==pnext)break;
        if(pprior==pnext&&pnext!=head){
            count++;
            break;
        }
        count+=2;
        pnext=pnext->m_pnext;
        pprior=pprior->m_pprior;
    }*/
    return count;
}
template <typename Type>
ListNode<Type>* DoublyList<Type>::find(int n){
    if(n<0){
        cout << "out of the boundary"<<endl;
        return NULL;
    }
    ListNode<Type>*pmove=head->m_pnext;
    for(int i = 0 ; i<n ;i++){
        pmove=pmove->m_pnext;
        if(pmove==head){
            cout << "out of the boundary"<<endl;
            return NULL;
        }
    }
    return pmove;
}
template <typename Type>
ListNode<Type> *DoublyList<Type>::findData(Type item){
    ListNode<Type>*prior = head->m_pprior;
    ListNode<Type>*next = head->m_pnext;
    while(next->m_pnext!=prior&&prior!=next){
        if(prior->m_data==item)return prior;
        if(next->m_data==item)return next;
        prior = prior->m_pprior;
        next = next->m_pnext;
    }
    cout<<"can't find the element"<<endl;
    return NULL;
}
template <typename Type>
bool DoublyList<Type> ::insert(Type item ,int n){
    if(n<0){
        cout << "the n is illegal"<<endl;
        return false;
    }
    ListNode<Type>*newNode = new ListNode<Type>(item);
    ListNode<Type>*pmove = head;
    for(int i = 0 ; i<n ;i++){
        pmove = pmove->m_pnext;
        if(pmove==head){
                cout << "the n is illegal"<<endl;
                return false;
        }
    }
    newNode->m_pnext = pmove->m_pnext;
    newNode->m_pprior = pmove;
    pmove->m_pnext = newNode;
    newNode->m_pnext->m_pprior = newNode;
    return true;
}
template <typename Type>
Type DoublyList<Type>::remove(int n =0){
    if(n<0){
        cout<< "out of the boundary"<<endl;
        exit(0);
    }
    ListNode<Type>*pdel = find(n);
    if(pdel!=NULL){
        pdel->m_pprior->m_pnext = pdel->m_pnext;
        pdel->m_pnext->m_pprior = pdel->m_pprior;
        Type item = pdel->m_data;
        delete pdel;
        return item;
    }
}
template <typename Type>
Type DoublyList<Type>::get(int n =0){
    if(n<0){
        cout << "out of the boundary"<<endl;
        exit(0);
    }
    ListNode<Type>*pmove = head;
    for(int i = 0 ; i <n ; i++){
        pmove = pmove->m_pnext;
        if(pmove==head){
            cout << "out of the boundary"<<endl;
            exit(0);
        }
    }
    return pmove->m_data;
}
template<typename Type>
void DoublyList<Type>::print(){
    ListNode<Type>*pmove = head->m_pnext;
    cout << "head";
    while(pmove!=head){
        cout << "->" << pmove->m_data;
        pmove= pmove->m_pnext;
    }
    cout << endl <<endl;
}

测试：

#include "stdafx.h"
#include "DoublyList.h"

int _tmain(int argc, _TCHAR* argv[])
{
    DoublyList<int>list;
    for(int i = 0 ; i<10 ;i++){
        list.insert(i*i,i);
    }
    list.print();
    cout << list.length() << endl;
    list.remove(0);
    list.print();
    list.remove(list.length()-1);
    list.print();
    return 0;
}