数据结构与算法——单向链表ADT（C++）

该单向链表类名字为Linked_list。

1.Linked_list类的基本数据成员：

        单向链表类Linked_list的基本数据成员包括：指向链表头节点的指针head，以及链表的节点数目size，如下所示：

Node *head;                                                 //当前链表的头节点
int size;                                                   //当前链表的节点数目  

        其中链表节点Node类的实现如下：

struct Node
{
    int data;
    Node *next=NULL;
    Node(int nums):data(nums),next(NULL)
    {
    }
};

2.Linked_list类的成员函数：

        Linked_list类的成员函数如下：

    //构造函数
    Linked_list();                                              //单向链表构造函数：构造空链表
    Linked_list(int nums[],int size);                           //单向链表构造函数：由数组构造链表
    Linked_list(const Linked_list &other);                      //拷贝构造函数
    //运算符
    Linked_list operator= (const Linked_list &other);           //拷贝构造运算符
    Linked_list operator+ (const Linked_list &other);           //加法运算符：将两个单向链表相连接
    //链表节点查找
    Node *search_by_content(int target);                        //根据内容查找节点的第一次出现的地址
    int search_by_position(int pos);                            //根据下标位置查找节点的内容
    //链表节点插入
    bool insert_by_position(int nums,int pos);                  //根据位置进行插入节点
    void insert_back(int nums);                                 //将指定的内容插入到链表的末尾
    //链表节点删除
    bool delete_by_content(int nums);                           //根据内容进行删除节点
    bool delete_by_position(int pos);                           //根据位置进行删除节点
    //单向链表特殊操作
    void reverse();                                             //将当前的链表反转
    void clean();                                               //将当前链表清空
    int count();                                                //返回当前链表的节点数目
    void print();                                               //输出链表的值

3.Linked_list类成员函数的实现：

Linked_list类成员函数的实现，实现的细节和需要注意的要点可以参见注释：

Linked_list::Linked_list()                        //单向链表构造函数：构造空链表
{
    size=0;
    head=NULL;
}

Linked_list::Linked_list(int nums[],int isize)     //单向链表构造函数：由数组构造链表
{
    //该函数既可以通过调用insert_back进行实现，也可以不调用
    //若决定调用insert_back成员函数进行实现，则必须先初始化head=NULL，size=0，因为insert_back函数需要链表的相关信息
    head=NULL;
    size=0;
    for(int i=0;i<isize;i++)
    {
        (*this).insert_back(nums[i]);        //该函数已经计算了链表节点数目
    }
}

Linked_list::Linked_list(const Linked_list &other)  //拷贝构造函数
{
    //链表的拷贝构造函数仅在链表构造的时候被调用，因此不需要考虑原链表是否为空
    //同样，若决定调用本类的insert_back成员函数进行实现，则必须初始化head=NULL，size=0，因为insert_back成员函数需要这些链表的相关信息
    head=NULL;     
    size=0;
    Node *now=other.head;
    while(now!=NULL)
    {       
        (*this).insert_back(now->data);    //该函数已经计算了链表节点数目
        now=now->next;
    }
}

Linked_list Linked_list::operator= (const Linked_list &other)         //拷贝构造运算符
{
    //链表的拷贝构造运算符需要考虑原链表是否为空，原链表非空的时候需要清空链表
    if(size)               //当原链表非空的时候，这时需要将原链表清空，否则会导致内存泄漏
    (*this).clean();    
    Node *now=other.head;
    while(now!=NULL)
    {
        (*this).insert_back(now->data);
        now=now->next;
    }      
    size=other.size;
    return (*this);
}

Linked_list Linked_list::operator+ (const Linked_list &other)         //加法运算符：将两个单向链表相连接
{
    Node *now=other.head;
    while(now!=NULL)
    {
        (*this).insert_back(now->data);
        now=now->next;
    }
    size+=other.size;
    return (*this);
}

Node *Linked_list::search_by_content(int target)                          //给定内容查找该内容所在的节点
{
    Node *now=head;
    while(now!=NULL