单链表(Singly Linked List)

最新推荐文章于 2024-04-21 19:20:09 发布
最新推荐文章于 2024-04-21 19:20:09 发布
阅读量3.9k 收藏 7
点赞数 2
分类专栏： C++数据结构 文章标签： 数据结构 单链表 静态链表 动态链表 单链表的优缺点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cainv89/article/details/50811624
版权

单链表(Singly Linked List)

1. 单链表的概念

1.1 单链表的定义
  • 单链表是线性表的链式存储表示。
1.2 单链表的结点结构
  • 单链表的结点包括两个部分：数据域和指针域。
    (1)数据域(data)，用于存储该结点的数据元素，数据元素类型由应用问题决定。
    (2)指针域(link)，用于存放一个指针，该指针指向下一个结点的开始存储地址。
  • 单链表的结点结构示意图：
    这里写图片描述
1.3 单链表中各结点的链接方式
  • 单链表由一系列结点(链表中每一个元素称为结点)组成，结点可以在运行时动态生成。
  • 单链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
  • 为了表示每个数据元素与其直接后继数据元素之间的逻辑关系，对数据元素来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息(即直接后继的存储位置)。由这两部分信息组成一个“结点”，表示线性表中一个数据元素。
  • 单链表要找一个数，必须要从表头开始找起，十分麻烦。
  • 单链表(带附加头结点的)中各结点的链接方式示意图：
    这里写图片描述

2. 单链表的实现

2.1 静态链表
  • 静态链表：链表中所有结点的数据内存中的分布都是在编译时就确定好，程序运行后不能进行改动。

  • 静态链表的实现——例1

    
#include <iostream>

using namespace std;

template <class T>
struct LinkNodeSimple
{
    T data;                  //数据域(data)，用于存储该结点的数据元素，数据元素类型由应用问题决定。
    LinkNodeSimple<T> *link; //指针域(link)，用于存放一个指针，该指针指向下一个结点的开始存储地址。
};

int main()
{
    LinkNodeSimple<int> node1, node2, node3, *head;
    node1.data = 1; 
    node2.data = 2; 
    node3.data = 3;
    head = &node1;       //将node1变量结构的开始地址作为一个结点赋给头指针head
    node1.link = &node2; //将node2变量结构的开始地址作为一个结点赋给node1变量结构的link指针成员
    node2.link = &node3; //将node3变量结构的开始地址作为一个结点赋给node2变量结构的link指针成员
    node3.link = NULL;   //将node3变量结构的link指针成员赋为空，即表示该结点是个尾结点

    //打印链表每一个结点的data值
    int count = 1;
    LinkNodeSimple<int> *p;
    p = head;//将p指针指向头结点head
    while(NULL != p)
    {
        cout<<"#"<<count<<" num = "<<p->data<<endl;
        p = p->link;//将p指针指向下一个结点
        count++;
    }

    system("pause");
    return 0;
}

  • 静态链表的实现——例2

    
#include <iostream>


#include <string>

using namespace std;

template <class T1, class T2>
struct LinkNode
{
    T1 data1;                  //数据域(data)，用于存储该结点的数据元素，数据元素类型由应用问题决定。
    T2 data2;                  //数据域(data)，用于存储该结点的数据元素，数据元素类型由应用问题决定。
    LinkNode<T1, T2> *link; //指针域(link)，用于存放一个指针，该指针指向下一个结点的开始存储地址。
};

int main()
{
    LinkNode<int, string> node1, node2, node3, *head;
    node1.data1 = 1; node1.data2 = "one";
    node2.data1 = 2; node2.data2 = "two";
    node3.data1 = 3; node3.data2 = "three";
    head = &node1;       //将node1变量结构的开始地址作为一个结点赋给头指针head
    node1.link = &node2; //将node2变量结构的开始地址作为一个结点赋给node1变量结构的link指针成员
    node2.link = &node3; //将node3变量结构的开始地址作为一个结点赋给node2变量结构的link指针成员
    node3.link = NULL;   //将node3变量结构的link指针成员赋为空，即表示该结点是个尾结点

    //打印链表每一个结点的data值
    int count = 1;
    LinkNode<int, string> *p;
    p = head;//将p指针指向头结点head
    while(NULL != p)
    {
        cout<<"#"<<count<<" num = "<<p->data1<<", name = "<<p->data2<<endl;
        p = p->link;//将p指针指向下一个结点
        count++;
    }

    system("pause");
    return 0;
}
2.2 动态链表
  • 动态链表：链表结构也可以是动态地分配存储的，即在需要时才开辟结点的存储空间。

  • 动态链表的实现：
    (1)链表的结点结构定义：LinkNode.h

    
#ifndef LINK_NODE_H_


#define LINK_NODE_H_



#include <iostream>


#include <string>


#include <strstream>


using namespace std;

template <class T>
struct LinkNode         //链表结点类的定义
{
    T data;             //数据域
    LinkNode<T> *link;  //指针域——后继指针
    //仅初始化指针成员的构造函数
    LinkNode(LinkNode<T>* ptr = NULL){ link = ptr; }
    //初始化数据与指针成员的构造函数
    LinkNode(const T& value, LinkNode<T>* ptr = NULL){ data = value; link = ptr; }
};


#endif /* LINK_NODE_H_ */

    (2)单链表的类定义及其操作的实现(带附加头结点)：LinkedList1.h

    
#ifndef LINKED_LIST1_H_


#define LINKED_LIST1_H_



#include "LinkNode.h"


template <class T>
class LinkedList//带附加头结点
{
public:
    LinkedList();                               //构造函数
    LinkedList(const LinkedList<T>& L);         //拷贝构造函数
    ~LinkedList();                              //析构函数
public:
    int Length()const;                          //计算链表的结点总数(除附加头结点)
    LinkNode<T>* Search(const T& x)const;       //搜索数据值为x的结点并返回
    LinkNode<T>* Locate(int i)const;            //获取第i个结点并返回
    bool GetData(int i, T& x)const;             //获取第i个结点的数据值保存至x，并返回获取成功与否
    bool SetData(int i, const T& x);            //修改第i个结点的数据值为x
    bool Insert(int i, const T& x);             //在第i个结点后插入数据值为x的新结点
    bool Remove(int i, T& x);                   //删除第i个结点，并将被删结点的数据值保存至x
    bool IsEmpty()const;                        //判断表是否为空
    bool IsFull()const;                         //判断表是否为满
    void Sort();                                //表排序——冒泡排序
    void InputFront(const T& endTag);           //前插法建立链表
    void InputRear(const T& endTag);            //后插法建立链表
    void Output()const;                         //输出所有结点的数据值
    void Reverse();                             //链表逆置
    void MakeEmpty();                           //清空链表(保留附加头结点)
    LinkedList<T>& operator=(const LinkedList<T>& L);   //链表间赋值操作——重载等号运算符
public:
    LinkNode<T>* GetHead()const;                //返回附加头结点的地址
    T get_value(string& s_value);               //返回输入的结点数据值
public:
    static bool IsNumber(const string& s_num);  //判断输入的字符串每个字符是否都是数值0~9
    static T StrToTtype(const string& s_num);   //类型转换——将string型转为模板类型T
private:
    LinkNode<T> *first; //链表的头结点
};

//构造函数
template<class T>
LinkedList<T>::LinkedList()
: first(new LinkNode<T>)
{
    cout << "$ 执行构造函数" << endl;
}

//拷贝构造函数
template<class T>
LinkedList<T>::LinkedList(const LinkedList<T>& L)
{
    cout << "$ 执行拷贝构造函数" << endl;
    LinkNode<T> *srcptr = L.GetHead();
    LinkNode<T> *destptr = first = new LinkNode<T>;
    while (NULL != srcptr->link)
    {
        srcptr = srcptr->link;
        destptr->link = new LinkNode<T>(srcptr->data);
        destptr = destptr->link;
    }
}

//析构函数
template<class T>
LinkedList<T>::~LinkedList()
{
    cout << "$ 执行析构函数" << endl;
    MakeEmpty();
}

//计算链表的结点总数(除附加头结点)
template<class T>
int LinkedList<T>::Length()const
{
    int count = 0;
    LinkNode<T> *curNode = first->link;
    while (NULL != curNode)
    {
        curNode = curNode->link;
        count++;
    }
    return count;
}

//搜索数据值为x的结点并返回
template<class T>
LinkNode<T>* LinkedList<T>::Search(const T& x)const
{
    LinkNode<T> *curNode = first->link;
    while ((NULL != curNode) && (x != curNode->data))
    {
        curNode = curNode->link;
    }
    return curNode;
}

//获取第i个结点并返回
template<class T>
LinkNode<T>* LinkedList<T>::Locate(int i)const
{
    if (i < 0)
    {
        return NULL;
    }
    if (0 == i)
    {
        return first;
    }
    int location = 1;
    LinkNode<T> *curNode = first->link;
    while ((location < i) && (NULL != curNode))
    {
        curNode = curNode->link;
        location++;
    }
    return curNode;
}

//获取第i个结点的数据值保存至x，并返回获取成功与否
template<class T>
bool LinkedList<T>::GetData(int i, T& x)const
{
    LinkNode<T> *curNode = Locate(i);
    if ((NULL == curNode) || (first == curNode))
    {
        return false;
    }
    x = curNode->data;
    return true;
}

//修改第i个结点的数据值为x
template<class T>
bool LinkedList<T>::SetData(int i, const T& x)
{
    LinkNode<T> *curNode = Locate(i);
    if ((NULL == curNode) || (first == curNode))
    {
        return false;
    }
    curNode->data = x;
    return true;
}

//在第i个结点后插入数据值为x的新结点
template<class T>
bool LinkedList<T>::Insert(int i, const T& x)
{
    LinkNode<T> *curNode = Locate(i);
    if (NULL == curNode)
    {
        return false;
    }
    LinkNode<T> *newNode = new LinkNode<T>(x);
    if (NULL == newNode)
    {
        cout << "* 存储分配错误" << endl;
        return false;
    }
    newNode->link = curNode->link;
    curNode->link = newNode;
    return true;
}

//删除第i个结点，并将被删结点的数据值保存至x
template<class T>
bool LinkedList<T>::Remove(int i, T& x)
{
    LinkNode<T> *preNode = Locate(i - 1);
    if (NULL == preNode)
    {
        return false;
    }
    LinkNode<T> *delNode = preNode->link;
    if ((NULL == delNode) || (first == delNode))
    {
        return false;
    }
    preNode->link = delNode->link;
    x = delNode->data;
    delete delNode;
    return true;
}

//判断表是否为空
template<class T>
bool LinkedList<T>::IsEmpty()const
{
    return (NULL == first->link) ? true : false;
}

//判断表是否为满
template<class T>
bool LinkedList<T>::IsFull()const
{
    return false;
}

//表排序——冒泡排序
template<class T>
void LinkedList<T>::Sort()
{
    LinkNode<T> *curNode = first->link;
    while (NULL != curNode)
    {
        LinkNode<T> *nextNode = curNode->link;
        while (NULL != nextNode)
        {
            if (curNode->data < nextNode->data)
            {
                T temp = curNode->data;
                curNode->data = nextNode->data;
                nextNode->data = temp;
            }
            nextNode = nextNode->link;
        }
        curNode = curNode->link;
    }
}

//前插法建立链表
//endTag是约定的输入序列结束的标志。如果输入序列是正整数，endTag可以是0或负数；
//如果输入序列是字符，endTag可以是字符集中不会出现的字符，如“\0”。
template<class T>
void LinkedList<T>::InputFront(const T& endTag)
{
    MakeEmpty();
    string s_value;
    T value = get_value(s_value);
    while (endTag != value)
    {
        LinkNode<T> *newNode = new LinkNode<T>(value);  //创建新结点
        if (NULL == newNode)
        {
            cout << "* 存储分配错误" << endl;
            break;
        }
        newNode->link = first->link;                    //新结点中指针域的指针指向链表的第一个结点
        first->link = newNode;                          //附加头结点中指针域的指针指向新结点
        value = get_value(s_value);
    }
}

//后插法建立链表
//endTag是约定的输入序列结束的标志。如果输入序列是正整数，endTag可以是0或负数；
//如果输入序列是字符，endTag可以是字符集中不会出现的字符，如“\0”。
template<class T>
void LinkedList<T>::InputRear(const T& endTag)
{
    MakeEmpty();
    LinkNode<T> *lastNode = first;                      //设置链表的最后一个结点为附加头结点
    string s_value;
    T value = get_value(s_value);
    while (endTag != value)
    {
        LinkNode<T> *newNode = new LinkNode<T>(value);  //创建新结点
        if (NULL == newNode)
        {
            cout << "* 存储分配错误" << endl;
            break;
        }
        lastNode->link = newNode;                       //最后一个结点中指针域的指针指向新结点
        lastNode = newNode;                             //设置最后一个结点为新结点
        value = get_value(s_value);
    }
}

//输出所有结点的数据值
template<class T>
void LinkedList<T>::Output()const
{
    LinkNode<T> *curNode = first->link;
    while (NULL != curNode)
    {
        cout << "curNode->data = " << curNode->data << endl;
        curNode = curNode->link;
    }
}

//链表逆置
template<class T>
void LinkedList<T>::Reverse()
{
    LinkNode<T> *prevNode = NULL;
    LinkNode<T> *curNode = first->link;
    LinkNode<T> *nextNode = NULL;
    while (NULL != curNode) 
    {
        nextNode = curNode->link;
        curNode->link = prevNode;
        prevNode = curNode;
        curNode = nextNode;
    }
    first->link = prevNode;
}

//清空链表(保留附加头结点)
template<class T>
void LinkedList<T>::MakeEmpty()
{
    LinkNode<T> *curNode = NULL;
    while (NULL != first->link)         //当链表不为空时，删去链表中所有结点
    {
        curNode = first->link;          //保存被删结点
        first->link = curNode->link;    //将链表附加头结点中指针域的指针指向被删结点的下一个结点
        delete curNode;                 //从链表上摘下被删结点
    }
}

//链表间赋值操作——重载等号运算符
template<class T>
LinkedList<T>& LinkedList<T>::operator=(const LinkedList<T>& L)
{
    cout << "$ 执行赋值操作函数" << endl;
    LinkNode<T> *srcptr = L.GetHead();
    LinkNode<T> *destptr = first = new LinkNode<T>;
    while (NULL != srcptr->link)
    {
        srcptr = srcptr->link;
        destptr->link = new LinkNode<T>(srcptr->data);
        destptr = destptr->link;
    }           
    return *this;
}

//返回附加头结点的地址
template<class T>
LinkNode<T>* LinkedList<T>::GetHead()const
{
    return first;
}

//返回输入的结点数据值
template <class T>
T LinkedList<T>::get_value(string& s_value)
{
    cout << "newNode->data = ";
    cin >> s_value;
    return StrToTtype(s_value);
}

//判断输入的字符串每个字符是否都是数值0~9
template <class T>
bool LinkedList<T>::IsNumber(const string& s_num)
{
    for (size_t i = 0; i < s_num.size(); i++)
    {
        if ((s_num[i] < '0') || (s_num[i] > '9'))
        {
            return false;
        }
    }
    return true;
}

//类型转换——将string型转为模板类型T
template <class T>
T LinkedList<T>::StrToTtype(const string& s_num)
{
    T n_num;
    strstream ss_num;
    ss_num << s_num;
    ss_num >> n_num;
    return n_num;
}


#endif /* LINKED_LIST1_H_ */

    (3)单链表的类定义及其操作的实现(不带附加头结点)：LinkedList2.h

    
#ifndef LINKED_LIST2_H_


#define LINKED_LIST2_H_



#include "LinkNode.h"


template <class T>
class LinkedList//不带附加头结点
{
public:
    LinkedList();                               //构造函数
    LinkedList(const LinkedList<T>& L);         //拷贝构造函数
    ~LinkedList();                              //析构函数
public:
    int Length()const;                          //计算链表的结点总数
    LinkNode<T>* Search(const T& x)const;       //搜索数据值为x的结点并返回
    LinkNode<T>* Locate(int i)const;            //获取第i个结点并返回
    bool GetData(int i, T& x)const;             //获取第i个结点的数据值保存至x，并返回获取成功与否
    bool SetData(int i, const T& x);            //修改第i个结点的数据值为x
    bool Insert(int i, const T& x);             //在第i个结点后插入数据值为x的新结点
    bool Remove(int i, T& x);                   //删除第i个结点，并将被删结点的数据值保存至x
    bool IsEmpty()const;                        //判断表是否为空
    bool IsFull()const;                         //判断表是否为满
    void Sort();                                //表排序——冒泡排序
    void InputFront(const T& endTag);           //前插法建立链表
    void InputRear(const T& endTag);            //后插法建立链表
    void Output()const;                         //输出所有结点的数据值
    void Reverse();                             //链表逆置
    void MakeEmpty();                           //清空链表
    LinkedList<T>& operator=(const LinkedList<T>& L);   //链表间赋值操作——重载等号运算符
public:
    LinkNode<T>* GetHead()const;                //返回头结点的地址
    T get_value(string& s_value);               //返回输入的结点数据值
public:
    static bool IsNumber(const string& s_num);  //判断输入的字符串每个字符是否都是数值0~9
    static T StrToTtype(const string& s_num);   //类型转换——将string型转为模板类型T
private:
    LinkNode<T> *first; //链表的头结点
};

//构造函数
template<class T>
LinkedList<T>::LinkedList()
: first(NULL)
{
    cout << "$ 执行构造函数" << endl;
}

//拷贝构造函数
template<class T>
LinkedList<T>::LinkedList(const LinkedList<T>& L)
{
    cout << "$ 执行拷贝构造函数" << endl;
    LinkNode<T> *srcptr = L.GetHead();
    LinkNode<T> *destptr = first = NULL;
    if (NULL != srcptr)
    {
        destptr = first = new LinkNode<T>(srcptr->data);
        while (NULL != srcptr->link)
        {
            srcptr = srcptr->link;
            destptr->link = new LinkNode<T>(srcptr->data);
            destptr = destptr->link;
        }
    }
}

//析构函数
template<class T>
LinkedList<T>::~LinkedList()
{
    cout << "$ 执行析构函数" << endl;
    MakeEmpty();
}

//计算链表的结点总数
template<class T>
int LinkedList<T>::Length()const
{
    int count = 0;
    LinkNode<T> *curNode = first;
    while (NULL != curNode)
    {
        curNode = curNode->link;
        count++;
    }
    return count;
}

//搜索数据值为x的结点并返回
template<class T>
LinkNode<T>* LinkedList<T>::Search(const T& x)const
{
    LinkNode<T> *curNode = first;
    while ((NULL != curNode) && (x != curNode->data))
    {
        curNode = curNode->link;
    }
    return curNode;
}

//获取第i个结点并返回
template<class T>
LinkNode<T>* LinkedList<T>::Locate(int i)const
{
    if (i <= 0)
    {
        return NULL;
    }
    int location = 1;
    LinkNode<T> *curNode = first;
    while ((location < i) && (NULL != curNode))
    {
        curNode = curNode->link;
        location++;
    }
    return curNode;
}

//获取第i个结点的数据值保存至x，并返回获取成功与否
template<class T>
bool LinkedList<T>::GetData(int i, T& x)const
{
    LinkNode<T> *curNode = Locate(i);
    if (NULL == curNode)
    {
        return false;
    }
    x = curNode->data;
    return true;
}

//修改第i个结点的数据值为x
template<class T>
bool LinkedList<T>::SetData(int i, const T& x)
{
    LinkNode<T> *curNode = Locate(i);
    if (NULL == curNode) 
    {
        return false;
    }
    curNode->data = x;
    return true;
}

//在第i个结点后插入数据值为x的新结点
template<class T>
bool LinkedList<T>::Insert(int i, const T& x)
{
    LinkNode<T> *newNode = new LinkNode<T>(x);
    if (NULL == newNode)
    {
        cout << "* 存储分配错误" << endl;
        return false;
    }
    if (0 == i)
    {
        newNode->link = first;
        first = newNode;
        return true;
    }
    LinkNode<T> *curNode = Locate(i);
    if (NULL != curNode)
    {
        newNode->link = curNode->link;
        curNode->link = newNode;
        return true;
    }
    delete newNode;
    return false;
}

//删除第i个结点，并将被删结点的数据值保存至x
template<class T>
bool LinkedList<T>::Remove(int i, T& x)
{
    if (NULL == first)
    {
        return false;
    }
    LinkNode<T> *delNode = NULL;
    if (1 == i)
    {   
        delNode = first;
        first = delNode->link;
    }
    else
    {
        LinkNode<T> *preNode = Locate(i - 1);
        if ((NULL == preNode) || (NULL == preNode->link))
        {
            return false;
        }
        delNode = preNode->link;
        preNode->link = delNode->link;
    }
    x = delNode->data;
    delete delNode;
    return true;
}

//判断表是否为空
template<class T>
bool LinkedList<T>::IsEmpty()const
{
    return (NULL == first) ? true : false;
}

//判断表是否为满
template<class T>
bool LinkedList<T>::IsFull()const
{
    return false;
}

//表排序——冒泡排序
template<class T>
void LinkedList<T>::Sort()
{
    LinkNode<T> *curNode = first;
    while (NULL != curNode)
    {
        LinkNode<T> *nextNode = curNode->link;
        while (NULL != nextNode)
        {
            if (curNode->data < nextNode->data)
            {
                T temp = curNode->data;
                curNode->data = nextNode->data;
                nextNode->data = temp;
            }
            nextNode = nextNode->link;
        }
        curNode = curNode->link;
    }
}

//前插法建立链表
//endTag是约定的输入序列结束的标志。如果输入序列是正整数，endTag可以是0或负数；
//如果输入序列是字符，endTag可以是字符集中不会出现的字符，如“\0”。
template<class T>
void LinkedList<T>::InputFront(const T& endTag)
{
    MakeEmpty();
    string s_value;
    T value = get_value(s_value);
    while (endTag != value)
    {
        LinkNode<T> *newNode = new LinkNode<T>(value);  //创建新结点
        if (NULL == newNode)
        {
            cout << "* 存储分配错误" << endl;
            break;
        }
        newNode->link = first;                          //新结点中指针域的指针指向链表的第一个结点
        first = newNode;                                //新结点成为头结点
        value = get_value(s_value);
    }
}

//后插法建立链表
//endTag是约定的输入序列结束的标志。如果输入序列是正整数，endTag可以是0或负数；
//如果输入序列是字符，endTag可以是字符集中不会出现的字符，如“\0”。
template<class T>
void LinkedList<T>::InputRear(const T& endTag)
{
    MakeEmpty();
    LinkNode<T> *lastNode = first;                      //设置链表的最后一个结点为头结点;
    string s_value;
    T value = get_value(s_value);
    while (endTag != value)
    {
        LinkNode<T> *newNode = new LinkNode<T>(value);  //创建新结点
        if (NULL == newNode)
        {
            cout << "* 存储分配错误" << endl;
            break;
        }
        if(NULL == lastNode)
        {
            first = newNode;                            //当链表为空时，新结点成为头结点
        }
        else
        {
            lastNode->link = newNode;                   //链表的最后一个结点中指针域的指针指向新结点
        }
        lastNode = newNode;                             //新结点成为链表的最后一个结点
        value = get_value(s_value);
    }
}

//输出所有结点的数据值
template<class T>
void LinkedList<T>::Output()const
{
    LinkNode<T> *curNode = first;
    while (NULL != curNode)
    {
        cout << "curNode->data = " << curNode->data << endl;
        curNode = curNode->link;
    }
}

//链表逆置
template<class T>
void LinkedList<T>::Reverse()
{
    LinkNode<T> *prevNode = NULL;
    LinkNode<T> *curNode = first;
    LinkNode<T> *nextNode = NULL;
    while (NULL != curNode) 
    {
        nextNode = curNode->link;
        curNode->link = prevNode;
        prevNode = curNode;
        curNode = nextNode;
    }
    first = prevNode;
}

//清空链表
template<class T>
void LinkedList<T>::MakeEmpty()
{
    LinkNode<T> *curNode = NULL;
    while (NULL != first)               //当链表不为空时，删去链表中所有结点
    {
        curNode = first;                //保存被删结点
        first = curNode->link;          //被删结点的下一个结点成为头结点
        delete curNode;                 //从链表上摘下被删结点
    }
}

//链表间赋值操作——重载等号运算符
template<class T>
LinkedList<T>& LinkedList<T>::operator=(const LinkedList<T>& L)
{
    cout << "$ 执行赋值操作函数" << endl;
    LinkNode<T> *srcptr = L.GetHead();
    LinkNode<T> *destptr = first = NULL;
    if (NULL != srcptr)
    {
        destptr = first = new LinkNode<T>(srcptr->data);
        while (NULL != srcptr->link)
        {
            srcptr = srcptr->link;
            destptr->link = new LinkNode<T>(srcptr->data);
            destptr = destptr->link;
        }
    }
    return *this;
}

//返回头结点的地址
template<class T>
LinkNode<T>* LinkedList<T>::GetHead()const
{
    return first;
}

//返回输入的结点数据值
template <class T>
T LinkedList<T>::get_value(string& s_value)
{
    cout << "newNode->data = ";
    cin >> s_value;
    return StrToTtype(s_value);
}

//判断输入的字符串每个字符是否都是数值0~9
template <class T>
bool LinkedList<T>::IsNumber(const string& s_num)
{
    for (size_t i = 0; i < s_num.size(); i++)
    {
        if ((s_num[i] < '0') || (s_num[i] > '9'))
        {
            return false;
        }
    }
    return true;
}

//类型转换——将string型转为模板类型T
template <class T>
T LinkedList<T>::StrToTtype(const string& s_num)
{
    T n_num;
    strstream ss_num;
    ss_num << s_num;
    ss_num >> n_num;
    return n_num;
}


#endif /* LINKED_LIST2_H_ */

    (4)主函数(main函数)的实现：main.cpp

    
#include "LinkedList1.h"    //带附加头结点

//#include "LinkedList2.h"  //不带附加头结点


#define EXIT 0              //退出


#define CONSTRUCT_COPY 1    //拷贝构造链表


#define LENGTH 2            //计算链表的结点总数


#define SEARCH 3            //搜索数据值为x的结点并返回


#define LOCATE 4            //获取第i个结点并返回


#define GETDATA 5           //获取第i个结点的数据值保存至x，并返回获取成功与否


#define SETDATA 6           //修改第i个结点的数据值为x


#define INSERT 7            //在第i个结点后插入数据值为x的新结点


#define REMOVE 8            //删除第i个结点，并将被删结点的数据值保存至x


#define ISEMPTY 9           //判断表是否为空


#define ISFULL 10           //判断表是否为满


#define SORT 11             //表排序——冒泡排序


#define INPUTFRONT 12       //前插法建立链表


#define INPUTREAR 13        //后插法建立链表


#define OUTPUT 14           //输出所有结点的数据值


#define REVERSE 15          //链表逆置


#define MAKEEMPTY 16        //清空链表


#define OPERATOR_COPY 17    //链表间赋值操作——重载等号运算符


#define GETHEAD 18          //返回头结点的地址


void print_description()
{
    cout << "------------------------------>单链表<------------------------------" << endl;
    cout << "功能选项说明：" << endl;
    cout << "#0： 退出" << endl;
    cout << "#1： 拷贝构造链表" << endl;
    cout << "#2： 计算链表的结点总数" << endl;
    cout << "#3： 搜索数据值为x的结点并返回" << endl;
    cout << "#4： 获取第i个结点并返回" << endl;
    cout << "#5： 获取第i个结点的数据值保存至x，并返回获取成功与否" << endl;
    cout << "#6： 修改第i个结点的数据值为x" << endl;
    cout << "#7： 在第i个结点后插入数据值为x的新结点" << endl;
    cout << "#8： 删除第i个结点，并将被删结点的数据值保存至x" << endl;
    cout << "#9： 判断表是否为空" << endl;
    cout << "#10：判断表是否为满" << endl;
    cout << "#11：表排序——冒泡排序" << endl;
    cout << "#12：前插法建立链表" << endl;
    cout << "#13：后插法建立链表" << endl;
    cout << "#14：输出所有结点的数据值" << endl;
    cout << "#15：链表逆置" << endl;
    cout << "#16：清空链表" << endl;
    cout << "#17：链表间赋值操作——重载等号运算符" << endl;
    cout << "#18：返回头结点的地址" << endl;
    cout << "--------------------------------------------------------------------" << endl;
}

//输入结点编号
template <class T>
int get_item()
{
    cout << "> 请输入结点编号，item = ";
    string s_item;
    cin >> s_item;
    while (false == LinkedList<T>::IsNumber(s_item))
    {
        cout << "* 输入有误，请重新输入：";
        cin >> s_item;
    }
    return atoi(s_item.c_str());
}

//输入数据值
template <class T>
T get_data()
{
    cout << "> 请输入数据值，data = ";
    string s_data;
    cin >> s_data;
    return LinkedList<T>::StrToTtype(s_data);
}

//输入结束标志位
template <class T>
T get_endtag()
{
    cout << "请输入结束标志值，endTag = ";
    string s_endTag;
    cin >> s_endTag;
    return LinkedList<T>::StrToTtype(s_endTag);
}

//构造单链表
template <class T>
LinkedList<T>* construct_linkedlist()
{
    cout << "\n==> 创建单链表" << endl;
    LinkedList<T> *linkedList = new LinkedList<T>;
    return linkedList;
}

//析构单链表
template <class T>
void destory_linkedlist(LinkedList<T>* linkedList)
{
    cout << "\n==> 释放单链表在堆中申请的空间，并将指向该空间的指针变量置为空" << endl;
    delete linkedList;
    linkedList = NULL;
}

//拷贝构造链表
template <class T>
void construct_copy(LinkedList<T>* linkedList)
{
    cout << "$ 执行拷贝构造链表函数" << endl;
    LinkedList<T> cpy_linkedlist = *linkedList;
    cpy_linkedlist.Output();
}

//计算链表的结点总数
template <class T>
void length(LinkedList<T>* linkedList)
{
    cout << "$ 执行计算链表的结点总数函数，Length = " << linkedList->Length() << endl;
}

//搜索数据值为x的结点并返回
template <class T>
void search(LinkedList<T>* linkedList)
{
    cout << "$ 执行搜索数据值为x的结点并返回函数" << endl;
    T data = get_data<T>();
    LinkNode<T> *node = linkedList->Search(data);
    if (NULL == node)
    {
        cout << "* 搜索失败" << endl;
        return;
    }
    cout << "* 搜索成功，data = " << node->data << endl;
}   

//获取第i个结点并返回
template <class T>
void locate(LinkedList<T>* linkedList)
{
    cout << "$ 执行获取第i个结点并返回函数" << endl;
    int n_item = get_item<T>();
    LinkNode<T> *node = linkedList->Locate(n_item);
    if ((NULL == node) || (linkedList->GetHead() == node))
    {
        cout << "* 获取失败" << endl;
        return;
    }
    cout << "* 获取成功，item = " << n_item << "，data = " << node->data << endl;
}

//获取第i个结点的数据值保存至x，并返回获取成功与否
template <class T>
void getdata(LinkedList<T>* linkedList)
{
    cout << "$ 执行获取第i个结点的数据值保存至x并返回获取成功与否函数" << endl;
    T data;
    int n_item = get_item<T>();
    if (false == linkedList->GetData(n_item, data))
    {
        cout << "* 获取失败" << endl;
        return;
    }
    cout << "* 获取成功，item = " << n_item << "，data = " << data << endl;
}

//修改第i个结点的数据值为x
template <class T>
void setdata(LinkedList<T>* linkedList)
{
    cout << "$ 执行修改第i个结点的数据值为x函数" << endl;
    int n_item = get_item<T>();
    T data = get_data<T>();
    if (false == linkedList->SetData(n_item, data))
    {
        cout << "* 修改失败" << endl;
        return;
    }
    cout << "* 修改成功，item = " << n_item << "，data = " << data << endl;
}

//在第i个结点后插入数据值为x的新结点
template <class T>
void insert(LinkedList<T>* linkedList)
{
    cout << "$ 执行在第i个结点后插入数据值为x的新结点函数" << endl;
    int n_item = get_item<T>();
    T data = get_data<T>();
    if (false == linkedList->Insert(n_item, data))
    {
        cout << "* 插入失败" << endl;
        return;
    }
    cout << "* 插入成功，item+1 = " << n_item+1 << "，data = " << data << endl;
}

//删除第i个结点，并将被删结点的数据值保存至x
template <class T>
void remove(LinkedList<T>* linkedList)
{
    cout << "$ 执行删除第i个结点并将被删结点的数据值保存至x函数" << endl;
    T data;
    int n_item = get_item<T>();
    if (false == linkedList->Remove(n_item, data))
    {
        cout << "* 删除失败" << endl;
        return;
    }
    cout << "* 删除成功，item = " << n_item << "，data = " << data << endl;
}

//判断表是否为空
template <class T>
void isempty(LinkedList<T>* linkedList)
{
    cout << "$ 执行判断表是否为空函数，IsEmpty = " << linkedList->IsEmpty() << endl;
}

//判断表是否为满
template <class T>
void isfull(LinkedList<T>* linkedList)
{
    cout << "$ 执行判断表是否为满函数，IsFull = " << linkedList->IsFull() << endl;
}

//表排序——冒泡排序
template <class T>
void sort(LinkedList<T>* linkedList)
{
    cout << "$ 执行表排序——冒泡排序函数" << endl;
    linkedList->Sort();
}

//前插法建立链表
template <class T>
void inputfront(LinkedList<T>* linkedList)
{
    cout << "$ 执行前插法建立链表函数" << endl;
    T endTag = get_endtag<T>();
    linkedList->InputFront(endTag);
}

//后插法建立链表
template <class T>
void inputrear(LinkedList<T>* linkedList)
{
    cout << "$ 执行后插法建立链表函数" << endl;
    T endTag = get_endtag<T>();
    linkedList->InputRear(endTag);
}

//输出所有结点的数据值
template <class T>
void output(LinkedList<T>* linkedList)
{
    cout << "$ 执行输出所有结点的数据值函数" << endl; 
    linkedList->Output();
}

//链表逆置
template <class T>
void reverse(LinkedList<T>* linkedList)
{
    cout << "$ 执行链表逆置函数" << endl;
    linkedList->Reverse();
}

//清空链表
template <class T>
void make_empty(LinkedList<T>* linkedList)
{
    cout << "$ 执行清空链表函数" << endl; 
    linkedList->MakeEmpty();
}

//链表间赋值操作——重载等号运算符
template <class T>
void operator_copy(LinkedList<T>* linkedList)
{
    cout << "$ 执行链表间赋值操作——重载等号运算符函数" << endl; 
    LinkedList<T> cpy_linkedlist;
    cpy_linkedlist = *linkedList;//或cpy_linkedlist.operator=(*linkedList);
    cpy_linkedlist.Output();
}

//返回头结点的地址
template <class T>
void gethead(LinkedList<T>* linkedList)
{       
    LinkNode<T> *head = linkedList->GetHead();
    cout << "$ 执行返回头结点的地址函数，&first = " << &head << endl;
}

//单链表操作选择
template <class T>
void select_operation(LinkedList<T>* linkedList)
{
    if (NULL == linkedList)
    {
        cout << "* 没有构造单链表，请先构造单链表。" << endl;
        return;
    }

    string s_operation;
    while (s_operation != "0")
    {
        cout << "\n==> 请输入功能选项编号(按\"0\"退出程序)：";
        cin >> s_operation;
        while (false == LinkedList<T>::IsNumber(s_operation))
        {
            cout << "* 输入有误，请重新输入：";
            cin >> s_operation;
        }
        int n_operation = atoi(s_operation.c_str());
        switch (n_operation)
        {
            case EXIT://退出
            {
                cout << "$ 退出程序" << endl;
                break;
            }
            case CONSTRUCT_COPY://拷贝构造链表
            {
                construct_copy(linkedList);
                break;
            }
            case LENGTH://计算链表的结点总数
            {
                length(linkedList);
                break;
            }
            case SEARCH://搜索数据值为x的结点并返回
            {
                search(linkedList);
                break;
            }
            case LOCATE://获取第i个结点并返回
            {
                locate(linkedList);
                break;
            }
            case GETDATA://获取第i个结点的数据值保存至x，并返回获取成功与否
            {
                getdata(linkedList);
                break;
            }
            case SETDATA://修改第i个结点的数据值为x
            {
                setdata(linkedList);
                break;
            }
            case INSERT://在第i个结点后插入数据值为x的新结点
            {
                insert(linkedList);
                break;
            }
            case REMOVE://删除第i个结点，并将被删结点的数据值保存至x
            {
                remove(linkedList);
                break;
            }
            case ISEMPTY://判断表是否为空
            {
                isempty(linkedList);
                break;
            }
            case ISFULL://判断表是否为满
            {
                isfull(linkedList);
                break;
            }
            case SORT://表排序——冒泡排序
            {
                sort(linkedList);
                break;
            }
            case INPUTFRONT://前插法建立链表
            {
                inputfront(linkedList);
                break;
            }
            case INPUTREAR://后插法建立链表
            {
                inputrear(linkedList);
                break;
            }
            case OUTPUT://输出所有结点的数据值
            {
                output(linkedList);
                break;
            }
            case REVERSE://链表逆置
            {
                reverse(linkedList);
                break;
            }
            case MAKEEMPTY://清空链表
            {
                make_empty(linkedList);
                break;
            }
            case OPERATOR_COPY://链表间赋值操作——重载等号运算符
            {
                operator_copy(linkedList);
                break;
            }
            case GETHEAD://返回头结点的地址
            {
                gethead(linkedList);
                break;
            }
            default:
            {
                cout << "* 请输入正确的功能选项编号" << endl;
                break;
            }
        }
    }
}

int main(int argc, char* argv[])
{
    print_description();
    LinkedList<int> *linkedList = construct_linkedlist<int>();
    select_operation(linkedList);
    destory_linkedlist(linkedList);
    system("pause");
    return 0;
}

3. 单链表的优缺点

3.1 优点
  • 没有空间限制，存储元素的个数无上限，基本只与内存空间大小有关。
  • 插入和删除元素速率高。
3.2 缺点
  • 占用额外的空间以存储指针(浪费空间)。
  • 随机存取元素速率低。
  • 单链表要找一个数，必须要从表头开始找起，十分麻烦。
3.3 单链表的适用情况
  • 适用于需要进行大量增加和删除元素操作而对访问元素无要求的，及预先无法确定表的大小的程序。

参考文献：
[1]《数据结构(用面向对象方法与C++语言描述)(第2版)》殷人昆——第二章
[2]《C/C++常用算法手册》秦姣华、向旭宇——第二章
[3] 百度搜索关键字：单链表的优缺点

Cainv89
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】链表LinkedList
qq_61862008的博客
11-18 1011
链表以及LinkedList介绍
SingleLinkedList（单链表）
Joeo8
01-22 680
SingleLinkedList（单链表） SingleLinkedList 单链表结构中，将数据存放在各个节点中。如下图所示，在每个节点内部，有两部组成。（data+next）即数据和指针。所谓单链表无疑是链式存储方式，节点中的next指针指向下一个节点，存储空间不是连续的。 单链表结构中有两种形式（下文以带头结点的单链表为例） 带头结点的单链表 头节点起标记作用，节点中不存放具体数据。 next指向第一个有具体数据的节点 不带头结点的单链表 Operation
【第二章 - 线性表之单链表】- 数据结构
melonyzzZ的博客
03-01 344
详解数据结构第二章 - 线性表之单链表
LinkedList和链表
最新发布
2301_78804510的博客
04-21 1121
方法解释尾插将e插入到index位置尾插c中的元素删除index位置元素删除遇到的第一个o获取下标index位置元素将下标index位置元素设置为element清空判断o是否在线性表中返回第一个o所在下标返回最后一个o的下标截取部分list4.3LinkedList的遍历// add(elem): 表示尾插// foreach遍历// 使用迭代器遍历---正向遍历// 使用反向迭代器---反向遍历。
数据结构之链表（LinkedList详解）
crazy_xieyi的博客
09-29 7513
LinkedList实现了List接口；LinkedList的底层使用了双向链表；LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问； LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)；ArrayList实质是顺序表，底层是一个数组。LinkedList实质是一个链表。ArrayList顺序表在物理上和逻辑上都是连续的，但是在扩容的时候，可能会造成空间的浪费。而LinkedList在物理上不一定是连续的，在逻辑上是连续的。
LinkedList与链表
qq_61688804的博客
07-07 244
LinkedList详解
链表(LinkedList)
weixin_51971817的博客
01-21 1813
链表是有序的列表，但是其在内存的存储不一定连续。
链表(Linked List)（单）（习题）
weixin_47027644的博客
03-18 187
获取单链表中节点的个数，不算头节点： public static int getLength(HeroNode head){ if(head.next == null){//空节点 return 0; } int length = 0; //辅助变量 HeroNode cur = head.next; int sum = 0; while(cur!=null).
danlianbiao.rar_singly linked list
09-21
在这个"danlianbiao.rar_singly linked list"的资源中，我们将深入探讨如何创建、操作和管理这种数据结构。 首先，我们来看"建立(头插法)"部分。头插法是向单链表的头部添加新节点的方法。在创建一个空链表时，通常...
Singly_Linked_List.rar
05-19
在提供的资源中，`singly_linked_list.h`是头文件，它定义了链表节点和链表结构。`functional_operation.cpp`包含了实现链表操作的函数，而`main.cpp`是主程序，用于测试这些操作。`Singly_Linked_List.exe`是编译后...
SinglyLinkedLists
01-28
单链表（Singly Linked List）是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用。在本主题中，我们将深入探讨单链表的"move to front"操作以及查找关键字（find keys...
Linked_List实现 链表
12-25
这个链表是我在数据结构大作业中写的，可直接运行。分享在这里供初学数据结构的同学参考
Singly_Linked_List.hpp
10-22
简单的单链表，C
singly_linked_list:单链列表，使用命令获取输入文件并输出结果列表
03-15
在这个项目中，"singly_linked_list"似乎是一个实现单链列表操作的代码库，可能是用C、C++或其他支持指针操作的语言编写的。"使用命令获取输入文件并输出结果列表"这部分描述可能指的是该项目提供了一个命令行工具，...
合并两个排序的链表(JS)
欣欣酱博客
03-09 829
输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。 示例1： 输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4 /** * Definition for singly-linked list. * function ListNode(val) { * this.val = val; * this.next = null; * } */ /** * @param {
线性表-单链表
program is a art
05-12 124
单链表（线性链表）：它用指针表示结点间的逻辑关系。一个存储结点包含data（数据域），link(指针域,链域)。它的特点是长度可以很方便的进行扩充。数据元素的顺序与其链表表示中结点的物理顺序可能不一致，一般通过指针将各数据元素按逻辑顺序链接起来 由于链接表的每个结点要带指针域，所以存储空间比顺序存储要付出较大的代价。 LinkedList.h [code="c++"] #ifndef LI...
基本的数据结构：单链表（Singly Linked List）
weixin_44795839的博客
07-27 3345
一.基本的数据结构单链表（Singly Linked List） 什么是单链表？ 下面是百度百科给出的官方解释： 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 其实通俗的来讲，单链表就是结构体变量...
表-单链表(list/singly-linked-list)
weixin_30613727的博客
01-29 91
单链表 链表是表ADT的一种链式映像。单链表是链表的一种，即每个结点只有一个指针域，指向和它相连的下一个结点。 (这里的链表是带有头结点的链表) 单链表的结点的声明与定义如下： //clare node (写于头文件之中) struct Node; typedef struct Node *PtrToNode; typedef struct PtrToNode Position; ...
0x00数据结构——C语言实现（单链表）
weixin_30628077的博客
04-23 231
0x00数据结构——C语言实现（单链表） /*filename:singly_linked_list.h*/ /* 单链表(singly linked list)是一种最简单的链表表示，也叫做线性链表。 用它来表示线性表时，用指针表示结点间的逻辑关系。 Functions: （在链表中增加附加头结点的版本） 创建一个空线性表 将链表...
given a constant k and a singly linked list l, you are supposed to reverse the links of every k elements on l. for example, given l being 1→2→3→4→5→6, if k=3, then you must output 3→2→1→6→5→4; if k=4, you must output 4→3→2→1→5→6.
04-11
题目描述：给定一个常数k和一个单链表l，你需要将l中每k个节点的链接翻转。例如，给定l为1->2->3->4->5->6，如果k=3，则必须输出3->2->1->6->5->4；如果k=4，则必须输出4->3->2->1->5->6。 解题思路：本题需要对链表进行操作，可以利用指针和递归。具体步骤如下： 1. 写一个递归的函数，输入参数为头结点head和翻转节点数k。 2. 先判断剩余的节点数是不是大于等于k，如果是则进行翻转，否则不进行翻转，直接返回头结点。 3. 对于翻转操作，可以利用三个指针pre、cur、next，分别指向前一个节点、当前节点和下一个节点。依次将当前节点指向前一个节点，然后依次向后移动三个指针。 4. 在翻转完k个节点后，递归调用函数，将返回的头结点连接到剩余节点的头结点。 5. 最后返回新的头结点。 代码如下： ``` class Solution { public: ListNode* reverseKGroup(ListNode* head, int k) { ListNode* cur = head; int count = 0; while (cur && count != k) { cur = cur->next; count++; } if (count == k) { cur = reverseKGroup(cur, k); while (count--) { ListNode* next = head->next; head->next = cur; cur = head; head = next; } head = cur; } return head; } }; ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值