单链表，循环链表，双向链表（C++实现）

单链表：
　　一.单链表与顺序表相比：

　　　1.顺序表可以方便的随机存取表中的任一节点，速度快；但是在表中插入删除一个数据时，为了保持其他元素的相对次序不变，平均需要移动一半的元素，效率很低；还有若事先对表长估计不足，过小会形成内存浪费，过大则需要拷贝到一个更大的数组，时间开销很大。相反，链表则适用于插入删除频繁，表长估计不定的情形。

　　　2.顺序表逻辑位置和物理位置都连续，而单链表中的逻辑位置连续，物理位置非连续。

　  二.为什么要带附加表头？

　　　　因为不带附加表头在插入删除时要分两种情况：操作节点在表头和不在表头；而带了附加表头便可以对所有节点一视同仁。

template<class T>
struct LinkNode{//链表节点 
    T data;
    LinkNode *link;
    LinkNode(const T& args,LinkNode<T> *ptr=NULL){
        data=args;
        link=ptr;
    }
};

template<class T>
class List{//带附加头节点的单链表 
    protected:
        LinkNode<T> *first;//链表头指针 
    public:
        List(){
            first=new LinkNode<T>;
        }
        List(const T& x){
            first=new LinkNode<T>(x);
        }
        List(List<T>& L){
            T value;
            LinkNode<T> *L_head=L.getHead();
            LinkNode<T> *temp=first=new LinkNode<T>;
            while(L_head->link!=NULL){
                value=L_head->link->data;
                temp->link=new LinkNode<T>(value);
                L_head=L_head->link;
                temp=temp->link; 
            }
            temp->link=NULL;
        }
        ~List(){
            makeEmpty();
        }
        void makeEmpty(){//将链表置空 
            LinkNode<T> *temp;
            while(first->link!=NULL){
                temp=first->link;
                first->link=temp->link;
                delete temp;
            }
        }
        int length()const{
            LinkNode<T> *temp=first->link;
            int count=0;
            while(temp!=NULL){
                temp=temp->link;
                count++;
            }
            return count;
        }
        LinkNode<T> *getHead()const{//返回附加头节点地址 
            return first;
        }
        LinkNode<T> *search(T x,int& i){//搜索数据x的地址和序列号 
            LinkNode<T> *current=first->link;
            int index=1;
            while(current!=NULL){
                if(current->data==x)
                    break;
                current=current->link;
                index++;
            } 
            i=index;
            return current;
        }
        LinkNode<T> *locate(int i){//搜索第i个节点的地址 
            if(i<0)
                return NULL;
            LinkNode<T> *current=first;
            int temp=0;
            while(current!=NULL&&temp<i){
                current=current->link;
                temp++;
            }
            return current;
        }
        bool getData(int i,T& x){//取出第i个元素的值 
            if(i<=0)
                return false;
            LinkNode<T> *current=locate(i);
            if(current==NULL) return false;
            x=current->data;
            return true; 
        }
        void setData(int i,T& x){//修改第i个元素的值 
            if(i<=0)
                return;
            LinkNode<T> *current=locate(i);
            if(current==NULL) return;
            current->data=x;
        }
        bool insert(int i,T& x){//在第i个元素后插入x 
            LinkNode<T> *current=locate(i);
            if(current==NULL) return false;
            LinkNode<T> *newNode=new LinkNode<T>(x);
            newNode->link=current->link;
            current->link=newNode;
            return true; 
        }
        bool remove(int i,T& x){//删除第i个元素的值 
            LinkNode<T> *current=locate(i-1);
            if(current==NULL||current->link==NULL) return false;
            LinkNode<T> *del=current->link;
            current->link=del->link;
            x=del->data;
            delete del;
            return true;
        }
        bool isEmpty()const{
            return (first->link==NULL)?true:false;
        }
        void inputFront(){//向前插入链表法 
            makeEmpty();
            LinkNode<T> *newNode;
            T value; 
            cin>>value;
            while(value!=-1){
                newNode=new LinkNode<T>(value);
                newNode->link=first->link;
                first->link=newNode;
                cin>>value;
            } 
        }
        void inputRear(){//向后插入链表法 
            makeEmpty();
            LinkNode<T> *newNode,*last=first;
            T value;
            cin>>value;
            while(value!=-1){
                newNode=new LinkNode<T>(value);
                last->link=newNode;
                last=newNode;
                cin>>value;
            }
        }
        void output(){//输出整个链表 
            LinkNode<T> *current=first->link;
            while(current!=NULL){
                cout<<current->data<<" ";
                current=current->link;
            }
            cout<<endl;
        }
};

测试代码如下：

void menu(){
    cout<<"1.向前插入建表（-1结束）"<<endl;
    cout<<"2.向后插入建表（-1结束）"<<endl;
    cout<<"3.输出链表"<<endl;
    cout<<"4.搜索元素x所在节点的序号"<<endl;
    cout<<"5.取出第i个元素的值"<<endl;
    cout<<"6.用x的值修改第i个元素的值"<<endl;
    cout<<"7.删除第i个元素"<<endl;
    cout<<"8.在第i个元素后面插入x"<<endl;
    cout<<"9.退出"<<endl;
} 

template<class T>
void function(int num,List<T> *list){
    switch(num){
        int x,i;
        case 1:
            list->inputFront();
            break;
        case 2:
            list->inputRear();
            break;
        case 3:
            list->output();
            break;
        case 4:
            cin>>x;
            list->search(x,i);
            cout<<i<<endl;
            break;
        case 5:
            cin>>i;
            list->getData(i,x);
            cout<<x<<endl;
            break;
        case 6:
            cin>>x>>i;
            list->setData(i,x);
            break;
        case 7:
            cin>>i;
            list->remove(i,x);
            break;
        case 8:
            cin>>i>>x;
            list->insert(i,x);
            break;
        default:
            exit(1);
    }
}
int main(int argc, char** argv) {
    int num;
    List<int> *list=new List<int>(-1);
    while(true){
        menu();
        cin>>num;
        function(num,list);
    }
    return 0; 
}

其次是循环链表：

　　代码我就不放了，就讲讲要修改的地方：

　　1.构造函数。first=new LinkNode<T>;后面接上:first->link=first;目的是让自身首尾相连。如图：

　　

　　　2.在判断循环指针是否到达表尾的条件要从NULL换成first。

　　　小结：

　　　循环链表的目的是只要知道表中任一一个节点的地址，就能遍历表中其他任一节点。

最后是双向链表：

　　修改：

　　1.节点的构造函数。需要增加一个前驱指针。

　　2.搜索、插入删除算法。首先是方向，确定方向后算法和单链表差不多，区别在于通过前驱指针还是后续指针访问节点。其次是插入删除，讲起来比较啰嗦，直接看图：

　　这是插入（中间是插入元素），虚线是原来的情况，实线是插入后的情况，可见一共涉及到4个指针。

　　这是删除（中间是删除元素）。看上去也是涉及4个指针，实际只动了1和4。

　　小结：

　　双向链表的目的是为了解决在链表中不同方向（前/后）访问元素的问题。