单链表。

#include <iostream>
#include <memory>
#include <sstream>

#include <list>

//线性表、栈,队列、树、图、哈希表

using namespace std;

//几年前就写过的东西,现在做,开始还在纠结node里面放值还是指针.后面想明白了.
//还是数据结构没学好.
//唉,数据结构和算法,node是一个数据结构.而linelist才是关于这个结构的使用.
//node是数据存放的格式.是一个数据类型.不要写成了class就看成是类.
//里面按链表的惯例就是放值的.至于node放堆还是栈,是linelist类来决定的.
//当然是放堆了.不然在,linelist的函数中,返回一个局部变量的指针是要怎样.
//这里的单链表,所有节点本身是在堆中,而指向第一个节点的头节点是linelink型的变量.附加上了第一节点后和最后一节点的信息,以及链表长度.
//这么清晰了.下次不会再糊涂了把.
template<typename T>
class LineNode
{
public:
    LineNode<T>(const T& v,const shared_ptr<LineNode<T>>& p):value(v),nextlineNode(p){}
    T value;
    shared_ptr<LineNode<T>> nextlineNode;
};

template<typename T>
class LineList
{
public:
    LineList():firstNode(0),endNode(0),size(0){}
    shared_ptr<LineNode<T>> Insert(const T& v)
    {
        shared_ptr<LineNode<T>> ret=shared_ptr<LineNode<T>>(new LineNode<T>(v,0));
        if(firstNode==0&& endNode==0&& size==0)
        {
            firstNode=endNode=ret;
            size=1;
        }
        else
        {
            endNode->nextlineNode=ret;
            endNode=ret;
            ++size;
        }
        return ret;
    }

    shared_ptr<LineNode<T>> InsertPosition(const T& v,int position)
    {
        shared_ptr<LineNode<T>> ret=0;
        if(position<size && position>=0)
        {
            if(position==0)
            {
                ret=shared_ptr<LineNode<T>>(new LineNode<T>(v,firstNode));
                firstNode=ret;
            }
            else if(position==size-1)
            {
                ret=shared_ptr<LineNode<T>>(new LineNode<T>(v,0));
                endNode->nextlineNode=ret;
                endNode=ret;
            }
            else
            {
                shared_ptr<LineNode<T>> preP=firstNode;
                for(int i=0;i!=position-1;++i)
                {
                    preP=preP->nextlineNode;
                }
                ret=shared_ptr<LineNode<T>>(new LineNode<T>(v,preP->nextlineNode));
                preP->nextlineNode=ret;

            }
            ++size;
        }
        else if(position==size && position==0)
        {
            ret=shared_ptr<LineNode<T>>(new LineNode<T>(v,0));
            firstNode=endNode=ret;
            size=1;
        }

        return ret;
    }

    void DeletePosition(int position)
    {
        if(size>0&& position>=0 && position<=size-1)
        {
            if(position==0)
            {
                firstNode=firstNode->nextlineNode;
            }
            else if(position==size-1)
            {
                shared_ptr<LineNode<T>> preP=firstNode;
                for(int i=0;i!=position-1;++i)
                {
                    preP=preP->nextlineNode;
                }
                preP->nextlineNode=0;
                endNode=preP;
            }
            else
            {
                shared_ptr<LineNode<T>> preP=firstNode;
                for(int i=0;i!=position-1;++i)
                {
                    preP=preP->nextlineNode;
                }
                preP->nextlineNode=preP->nextlineNode->nextlineNode;
                //preP->nextlineNode->nextlineNode引述+1
                //delete preP->nextlineNode ==>引述-1.=0,并删除.
                //~(preP->nextlineNode->nextlineNode)==>preP->nextlineNode->nextlineNode-1
                //
            }
            --size;
        }
    }

    shared_ptr<LineNode<T>> firstNode;
    shared_ptr<LineNode<T>> endNode;
    int size;
};

template<typename T>
void showList(const LineList<T>& ll)
{
    int ff=ll.firstNode==0?-99:ll.firstNode->value;
    int end=ll.endNode==0?-99:ll.endNode->value;

    cout<<"size:"<<ll.size<<". first:"<<ff<<". end:"<<end<<endl;

    shared_ptr<LineNode<T>> temp=ll.firstNode;

    while(temp!=0)
    {
        cout<<temp->value;
        if(temp->nextlineNode!=0)
        {
            temp=temp->nextlineNode;
        }
        else
        {
            break;
        }
    }
    cout<<endl;
}

LineList<int> haha()
{
    LineList<int> myList;

    //myList.Insert(3);
    //showList(myList);
    myList.InsertPosition(3,0);

    myList.InsertPosition(4,0);

    myList.InsertPosition(7,1);

    myList.InsertPosition(1,0);

    myList.InsertPosition(8,-1);

    return myList;
}

int main()
{
    //测试.空链表.测试大小.头尾. 结果为0
    //1)插入第一条数据.头尾一样.size为1. 测试遍历方法.
    //2)尾部插入,测试大小.头尾.
    //3)中间插入.测试大小.头尾.
    //4)删除头尾,删除中间.
    //5)只有一条数据删除.
    //6)删除不存在的位置.
    //7)没有记录的删除.

    haha();

    LineList<int> myll2=haha();

    showList(myll2);

    return 0;
}