单链表的模板类实现

最新推荐文章于 2024-02-23 16:10:03 发布
最新推荐文章于 2024-02-23 16:10:03 发布
阅读量1.3w 收藏 75
点赞数 23
分类专栏： 小白数据结构 文章标签： 单链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/avalon_y/article/details/50869098
版权

数据结构是初学编程时候的一个天坑，去年大一的时候学的那叫一个惨烈，虽然C++提供标准的list类库，但是自己动手实现这些常用的数据结构，不仅能对数据结构的认识更深，也对C++中深浅复制，重载，复用等内容更好的理解。
线性表的链式存储结构是用一组任意的存储单元存储线性表的数据元素(这组存储单元可以是连续的也可以是不连续的)，因此为了表示每个数据元素与其直接后继的逻辑关系，除了存储本身的信息之外，还需要一个存储一个直接后继的位置信息。这两部分组成的存储映射，称为结点（node）.
这里写图片描述
一个结点包含数据域和指针域两个部分，一个链表由若干个结点依次链接构成，其中第一个结点为头结点，最后一个节点的直接后继为NULL。
那么实现一个单链表的第一步就是选择一个合适的结构来实现node。
这里有很多种方法，比如将node声明为struct可直接被LinkList类使用，或者将node声明为类，LinkList类public继承node类或是用嵌套类定义等方法。这里好像没什么优劣之分吧，根据个人喜好选择吧。

using namespace std;
template <class Temp>
struct LinkNode
{
    Temp data;
    LinkNode<Temp> *next;     //struct构造函数
    LinkNode(const Temp &item, LinkNode<Temp> *ptr = NULL) 
    //函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面
    {
        next = ptr;
        data = item;
    }
};

看到这里，可能有朋友会问了，这玩意是啥？结构还是类，在上述LinkNode结构中，居然出现了模板类的定义方法和构造函数，其实结构可以看做为一种默认为public的类。这里的构造函数提供的默认值为NULL可以省去检测链表尾结点是否指向NULL的麻烦。
好了，现在结点有了，那我们来看看怎么定义LinkList这个模板类吧，先给出来，在慢慢解释。

template <class Temp>
struct LinkNode
{
    Temp data;
    LinkNode<Temp> *next;
    LinkNode(LinkNode<Temp> *ptr = NULL){ next = ptr; }    //struct构造函数
    LinkNode(const Temp &item, LinkNode<Temp> *ptr = NULL) //函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面
    {
        next = ptr;
        data = item;
    }
};

template <class Temp>
class LinkList
{
public:

    LinkList(){
        Head = new LinkNode<Temp>; 
        if (NULL == Head)
        {
            cerr << "分配内存失败!" << endl;
            exit(1);
        }
    };
    //无参构造函数

    LinkList(const Temp &item);
    //含参构造函数

    LinkList(const LinkList &copy);
    //拷贝构造函数

    LinkList<Temp>& operator= (LinkList<Temp> &List);

    ~LinkList();
    //析构函数

    void CreateLink(int nLinkList);
    //创建长度为nLinkList的单链表

    void DestoryList();
    //摧毁线性表

    void ClearList();
    //清空单链表

    bool ListIsLoop() const;
    //链表是否有环

    bool ListEnpty() const;
    //判断链表是否为空,为空返回true，否则返回false

    int ListLength() const;
    //返回链表中数据元素个数

    bool GetElem(int pos, Temp &item);
    //用item获取第pos个数据元素的值,false表示失败

    void SetHead(LinkNode<Temp> *p);
    //设置链表头结点

    LinkNode<Temp>* Find(Temp &item);
    // 返回第一个找到的满足该数据元素的结点对应的指针

    LinkNode<Temp>* Locate(int pos);
    //返回第pos个数据元素对于的指针

    bool LinkInsert(Temp item, int pos);
    //将数据元素item插入到第i个结点的位置，成功返回true，否则返回false

    bool LinkDelete(Temp &item,int pos);
    //将第pos个结点删除，并用item返回该数据对象


    void Print() const;
    //打印链表

    void Sort();
    //链表排序

    void Reverse();
    void Reverse(int nStart, int nEnd);
    //链表逆置

    void LinkSwap(int pos1, int pos2);
    void LinkSwap(LinkNode<Temp> * p1, LinkNode<Temp> * p2);
    //交换两个结点内容

    bool LinkIsPalindrome();
    //单链表是不回文
private:
    LinkNode<Temp> *Head;
};

好了我们的链表完成了，整个链表的数据有什么？只有一个类型为LinkNode的Head指针！！！
曾经看到不少对于单链表的提问是这样的
这里写图片描述
不管是用类的继承或是嵌套类，创建一个单链表只有唯一的一个LinkList对象，它会链接多个LinkNode对象。

①构造函数
I.无参构造函数

    LinkList(){
            try
            {
                Head = new ListNode<Temp>;
            }
            catch (const bad_alloc & e)
            {
                cerr << "分配内存失败!" << endl;
                exit(1);
            }
        };

没什么好说的，用new从堆分配一个结点的空间给我们都头结点指针，注意检查堆是否满是一个很好的习惯。
II.含参构造函数
这里是函数通过参数列表复用，可以将头结点的数据域利用起来保存一些例如链表长度等信息。

template <class Temp>
LinkList<Temp>::LinkList(const Temp &item)
    {
        try
        {
            Head = new ListNode<Temp>(item);
        }
        catch (const bad_alloc & e)
        {
            cerr << "分配内存失败!" << endl;
            exit(1);
        }
    }

此处定义是放在类定义之外的，所有要再声明模板类型，并提供名称空间。

②创建单链表
按照大多数数据结构的书会先介绍某个位置节点的插入和删除，再在链表的创建中调用这些方法，但是连就一个头结点你就来介绍插入、删除某个结点了，我接受不了，虽然代码复用性会降低，但我们还是一步一步的来。
这里写图片描述
首先定义一个指向Head的指针q；
然后不断重复以下三个步骤完成单链表的构造：
①用new申请一个LinkNode的空间返回指针p，并输入数据元素；
②q->next=p，将q指针对应结点的后继修改为p；
③q=q->next,将指针指向其直接后继，这样一个结点就被链接进了链表之中。


void LinkList<Temp>::CreateLink(int n)
    {
        //输入n个元素的值，建立包含头结点的单链表

        LinkNode<Temp> *q = Head;

        cout << "Enter the  element:  ";
        int *nodetemp = new int[n];
        for (size_t i = 0; i < n; i++)
        {
            cin >> nodetemp[i];
        }
        for (size_t i = 0; i < n; i++)
        {
            try
            {
                LinkNode<Temp> * p = new LinkNode<Temp>;
                p->data = nodetemp[i];
                p->next = q->next;
                q->next = p;
                q = q->next;
            }
            catch (const bad_alloc &e)
            {
                cerr << "分配内存失败!" << endl;
                exit(1);
            }

        }
        delete[] nodetemp;

    }

这里就有个更大的问题了！！！你new了这么多次，都不释放，这不是会导致内存泄露吗？
new发生内存泄露的原因是当指针的生命周期结束后，会自动消亡，而再内存池中分配的内存却无法被释放，但是对于链表，虽然原来指向每一个结点对应地址的指针都没了，但在LinkList的生命周期内，只要头结点存在，且链路正常，就可以依次找到所有的存储空间并释放它。所有我们只需要在链表对象生命周期结束时释放全部内存即可。
③析构函数（单链表的删除）
单链表的删除很简单用两个指针，从头结点开始，一前一后依次释放申请的内存即可。

template <class Temp>
void LinkList<Temp>::DestoryList()
{
    LinkNode<Temp> *p=Head;
    LinkNode<Temp> *t;
    while (p)
    {
        t = p->next;
        delete p;
        p = t;
    }
}

析构函数直接调用了链表的删除操作即可

template <class Temp>
LinkList<Temp>::~LinkList()
{
    DestoryList();
}

好了写到这里，虽然还有很多的操作没写但是基本上单链表的框架有了啊，我们来测试一下吧。

#include <iostream>
#include "LinkList.h"

int main()
{
    using namespace std;
    LinkList<int> text;
    text.CreateLink(5);
    LinkList<int> c=text;
    cin.get();
    return 0;
}

虽然无法输，但是运行应该没问题吧！
这里写图片描述

咕~~(╯﹏╰)b
什么鬼，深浅拷贝的问题，一张图说明什么是深浅拷贝
这里写图片描述
浅拷贝只是将对象B也指向A存储的内容，那么问题来了，A对象析构之后，B对象怎么办？
而深拷贝就是分配了资源，数据有自己独立不同的存储地址和空间，两个对象之间的析构不会互相干扰。
因此好的习惯的显示定义类的构造函数，拷贝构造函数，和赋值函数。
我们首先来看看拷贝赋值函数。
④拷贝构造函数和赋值函数
操作都很简单，依次分配内存拷贝链接即可，类似于链表的构建。区别在于拷贝构造还没有LinkList对象，需要创建，而赋值已经有了LinkList对象，需要将其链表删除再重新构造。

template <class Temp>
    LinkList<Temp>::LinkList(const LinkList &copy)
    {

        LinkNode<Temp> *p = copy.Head->next;
        try
        {
            Head = new LinkNode<Temp>;
            LinkNode<Temp> *h = Head;
            while (p != NULL)
            {
                LinkNode<Temp> *t = new LinkNode<Temp>;
                h->next = t;
                t->data = p->data;
                p = p->next;
                h = h->next;
            }
        }
        catch (const bad_alloc & e)
        {
            cerr << "分配内存失败!" << endl;
            exit(1);
        }
    }

template <class Temp>
    LinkList<Temp> &  LinkList<Temp>::operator=(LinkList<Temp> &List)
    {
        try
        {
            LinkList<Temp> temp(*this);
            temp.DestoryList();
            LinkNode<Temp> *p = List.Head;
            LinkNode<Temp> *h = temp.Head;
            while (p != NULL)
            {
                LinkNode<Temp> *t = new LinkNode<Temp>;
                h->next = t;
                t->data = p->data;
                p = p->next;
                h = h->next;
            }
            swap(temp);
            return *this;
        }
        catch (const bad_alloc & e)
        {
            cerr << "error !" << endl;
            return *this;
        }

    }

这里要注意对=的重载返回的是类的引用。
LinkList c=text ; 会调用拷贝构造函数

LinkList c；
c=text; 会调用赋值函数

⑤插入和删除
插入
这里写图片描述
将前一节点的后继指向新结点，在将新结点的后继指向前一结点的后继即可；
这里写图片描述

template <class Temp>
    bool LinkList<Temp>::LinkInsert(Temp item, int pos)
    {
        using std::cerr;
        using std::endl;
        LinkNode<Temp> *p = Locate(pos - 1);

        if (p == NULL)
        {
            return false;
        }
        try
        {
            LinkNode<Temp> *node = new LinkNode<Temp>(item);
            node->next = p->next;
            p->next = node;
            return true;
        }
        catch (const bad_alloc &e)
        {
            cerr << "Error!";
            return false;
        }
    }

删除
这里写图片描述
将上一结点的后继指向后继的后继，在释放待删除结点
这里写图片描述

template <class Temp>
    bool LinkList<Temp>::LinkDelete(Temp &item, int pos)
    {
        LinkNode<Temp> *p = Locate(pos-1);
        if (NULL == p || NULL == p->next)
            return false;


        LinkNode<Temp> *del = p->next;
        p->next = del->next;
        item = del->data;
        delete del;
        return true;
    }

其他不在单独介绍了，需要注意的是单链表的翻转需要三个指针才能完成（可能是比较蠢的方法就不多说了），完整的单链表文件如下：

//ListNode.h
#ifndef LISTNODE_H_
#define LISTNODE_H_
//单链表的结点定义
using namespace std;
namespace Link
{

    template <class Temp>
    struct LinkNode
    {
        Temp data;
        LinkNode<Temp> *next;
        LinkNode(LinkNode<Temp> *ptr = NULL){ next = ptr; }    //struct构造函数
        LinkNode(const Temp &item, LinkNode<Temp> *ptr = NULL) //函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面
        {
            next = ptr;
            data = item;
        }
    };

    template <class Temp>
    class LinkList
    {
    public:

            LinkList(){
            try
            {
                Head = new ListNode<Temp>;
            }
            catch (const bad_alloc & e)
            {
                cerr << "分配内存失败!" << endl;
                exit(1);
            }
        };
        //无参构造函数

        LinkList(const Temp &item);
        //含参构造函数

        LinkList(const LinkList &copy);
        //拷贝构造函数

        LinkList<Temp>& operator= (LinkList<Temp> &List);

        ~LinkList();
        //析构函数

        void CreateLink(int nLinkList);
        //创建长度为nLinkList的单链表

        void DestoryList();
        //摧毁线性表

        void ClearList();
        //清空单链表

        bool ListIsLoop() const;
        //链表是否有环

        bool ListEnpty() const;
        //判断链表是否为空,为空返回true，否则返回false

        int ListLength() const;
        //返回链表中数据元素个数

        bool GetElem(int pos, Temp &item);
        //用item获取第pos个数据元素的值,false表示失败

        void SetHead(LinkNode<Temp> *p);
        //设置链表头结点

        LinkNode<Temp>* Find(Temp &item);
        // 返回第一个找到的满足该数据元素的结点对应的指针

        LinkNode<Temp>* Locate(int pos);
        //返回第pos个数据元素对于的指针

        bool LinkInsert(Temp item, int pos);
        //将数据元素item插入到第i个结点的位置，成功返回true，否则返回false

        bool LinkDelete(Temp &item, int pos);
        //将第pos个结点删除，并用item返回该数据对象


        void Print() const;
        //打印链表

        void Sort();
        //链表排序

        void Reverse();
        void Reverse(int nStart, int nEnd);
        //链表逆置

        void LinkSwap(int pos1, int pos2);
        void LinkSwap(LinkNode<Temp> * p1, LinkNode<Temp> * p2);
        //交换两个结点内容

        bool LinkIsPalindrome();
        //单链表是不回文

        void swap(LinkList<Temp> & other);

    private:
        LinkNode<Temp> *Head;
    };

    template <class Temp>
    LinkList<Temp>::LinkList(const Temp &item)
    {
        try
        {
            Head = new ListNode<Temp>(item);
        }
        catch (const bad_alloc & e)
        {
            cerr << "分配内存失败!" << endl;
            exit(1);
        }
    }

    template <class Temp>
    LinkList<Temp>::LinkList(const LinkList &copy)
    {

        LinkNode<Temp> *p = copy.Head->next;
        try
        {
            Head = new LinkNode<Temp>;
            LinkNode<Temp> *h = Head;
            while (p != NULL)
            {
                LinkNode<Temp> *t = new LinkNode<Temp>;
                h->next = t;
                t->data = p->data;
                p = p->next;
                h = h->next;
            }
        }
        catch (const bad_alloc & e)
        {
            cerr << "分配内存失败!" << endl;
            exit(1);
        }
    }

    template <class Temp>
    LinkList<Temp> &  LinkList<Temp>::operator=(LinkList<Temp> &List)
    {
        try
        {
            LinkList<Temp> temp(*this);
            temp.DestoryList();
            LinkNode<Temp> *p = List.Head;
            LinkNode<Temp> *h = temp.Head;
            while (p != NULL)
            {
                LinkNode<Temp> *t = new LinkNode<Temp>;
                h->next = t;
                t->data = p->data;
                p = p->next;
                h = h->next;
            }
            swap(temp);
            return *this;
        }
        catch (const bad_alloc & e)
        {
            cerr << "error !" << endl;
            return *this;
        }

    }

    template <class Temp>
    LinkList<Temp>::~LinkList()
    {
        DestoryList();
    }

    template <class Temp>
    void LinkList<Temp>::CreateLink(int n)
    {
        //输入n个元素的值，建立包含头结点的单链表

        LinkNode<Temp> *q = Head;

        cout << "Enter the  element:  ";
        int *nodetemp = new int[n];
        for (size_t i = 0; i < n; i++)
        {
            cin >> nodetemp[i];
        }
        for (size_t i = 0; i < n; i++)
        {
            try
            {
                LinkNode<Temp> * p = new LinkNode<Temp>;
                p->data = nodetemp[i];
                p->next = q->next;
                q->next = p;
                q = q->next;
            }
            catch (const bad_alloc &e)
            {
                cerr << "分配内存失败!" << endl;
                exit(1);
            }

        }
        delete[] nodetemp;

    }

    template <class Temp>
    void LinkList<Temp>::DestoryList()
    {
        LinkNode<Temp> *p = Head;
        LinkNode<Temp> *t;
        while (p)
        {
            t = p->next;
            delete p;
            p = t;
        }
    }

    template <class Temp>
    void LinkList<Temp>::ClearList()
    {
        LinkNode<Temp> *p = Head;

        while (p)
        {
            p->data = NULL;
            p = p->next;
        }
    }
    template <class Temp>
    void LinkList<Temp>::Print() const
    {
        using std::cout;
        using std::endl;
        LinkNode<Temp> *p = Head->next;

        while (p)
        {
            cout << p->data << "  ";
            p = p->next;
        }
        cout << endl;
    }

    template <class Temp>
    bool LinkList<Temp>::ListEnpty() const
    {
        LinkNode<Temp> *p = Head->next;

        while (p)
        {
            if (p->data == NULL)
            {
                return true;
            }
            p = p->next;
        }
        return false;
    }


    template <class Temp>
    int LinkList<Temp>::ListLength() const
    {
        LinkNode<Temp> *p = Head->next;
        int nLink = 0;
        while (p)
        {
            nLink++;
            p = p->next;
        }
        return nLink;
    }

    template <class Temp>
    bool LinkList<Temp>::GetElem(int pos, Temp &item)
    {
        LinkNode<Temp> *p = Locate(pos);
        if (p == NULL)
        {
            return false;
        }
        item = p->data;
        return true;
    }

    template <class Temp>
    void LinkList<Temp>::SetHead(LinkNode<Temp> *p)
    {
        Head->data = p->data;
        Head->next = p->next;
    }

    template <class Temp>
    LinkNode<Temp>* LinkList<Temp>::Find(Temp &item)
    {
        LinkNode<Temp> *p = Head->next;
        while (p)
        {
            if (p->data == item)
            {
                break;
            }
            p = p->next;
        }
        return p;
    }


    template <class Temp>
    LinkNode<Temp>* LinkList<Temp>::Locate(int pos)
    {
        LinkNode<Temp> *p = Head;
        while (pos--)
        {
            p = p->next;
        }
        return p;
    }

    template <class Temp>
    bool LinkList<Temp>::LinkInsert(Temp item, int pos)
    {
        using std::cerr;
        using std::endl;
        LinkNode<Temp> *p = Locate(pos - 1);

        if (p == NULL)
        {
            return false;
        }
        try
        {
            LinkNode<Temp> *node = new LinkNode<Temp>(item);
            node->next = p->next;
            p->next = node;
            return true;
        }
        catch (const bad_alloc &e)
        {
            cerr << "Error!";
            return false;

        }
    }
    template <class Temp>
    bool LinkList<Temp>::LinkDelete(Temp &item, int pos)
    {
        LinkNode<Temp> *p = Locate(pos - 1);
        if (NULL == p || NULL == p->next)
            return false;


        LinkNode<Temp> *del = p->next;
        p->next = del->next;
        item = del->data;
        delete del;
        return true;
    }


    template<class Temp>
    void LinkList<Temp>::Reverse()
    {
        LinkNode<Temp> *pre = Head->next;
        LinkNode<Temp> *curr = pre->next;
        LinkNode<Temp> *next = NULL;

        Head->next->next = NULL;
        while (curr)
        {
            next = curr->next;
            curr->next = pre;
            pre = curr;
            curr = next;
        }

        Head->next = pre;
    }

    template<class Temp>
    void LinkList<Temp>::Reverse(int nStart, int nEnd)
    {
        LinkNode<Temp> *start = Locate(nStart - 1);
        LinkNode<Temp> *end = Locate(nEnd);
        LinkNode<Temp> *pre = Locate(nStart);
        LinkNode<Temp> *curr = pre->next;
        LinkNode<Temp> *next = NULL;

        pre->next = end->next;
        while (pre != end)
        {
            next = curr->next;
            curr->next = pre;
            pre = curr;
            curr = next;
        }

        start->next = pre;


    }
    template<class Temp>
    void LinkList<Temp>::LinkSwap(int pos1, int pos2)
    {
        LinkNode<Temp> *p1 = Locate(pos1);
        LinkNode<Temp> *p2 = Locate(pos2);
        Temp t = p1->data;
        p1->data = p2->data;
        p2->data = t;

    }




    template<class Temp>
    void LinkList<Temp>::LinkSwap(LinkNode<Temp> * p1, LinkNode<Temp> * p2)
    {
        Temp t = p1->data;
        p1->data = p2->data;
        p2->data = t;
    }




    template<class Temp>
    void LinkList<Temp>::Sort()
    {
        LinkNode<Temp> *p = Head;
        for (int i = 1; i <ListLength(); i++)
        {
            p = Locate(1);
            for (int j = 1; j <= ListLength() - i; j++)
            {
                if (p->data >(p->next->data))
                {
                    LinkSwap(p, p->next);
                }
                p = p->next;
            }
        }
    }


    template<class Temp>
    bool LinkList<Temp>::ListIsLoop() const
    {
        LinkNode *slow = Head;
        LinkNode *fast = Head;
        while (fast->next != NULL)
        {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast)
            {
                return true;
            }
        }
        return false;
    }

    template<class Temp>
    bool LinkList<Temp>::LinkIsPalindrome()
    {
        int len = ListLength();
        if (len % 2 == 0)
        {
            Reverse((len / 2) + 1, len);
            LinkNode<Temp> *p1 = Locate(1);
            LinkNode<Temp> *p2 = Locate((len / 2) + 1);
            while (p2->next != NULL)
            {
                if (p1->data != p2->data)
                {
                    return false;
                }
                p2 = p2->next;
                p1 = p1->next;
            }
            return true;
        }
        else
        {
            Reverse((len / 2) + 2, len);
            LinkNode<Temp> *p1 = Locate(1);
            LinkNode<Temp> *p2 = Locate((len / 2) + 2);
            while (p2->next != NULL)
            {
                if (p1->data != p2->data)
                {
                    return false;
                }
                p2 = p2->next;
                p1 = p1->next;
            }
            return true;
        }
    }
    template<class Temp>
    void LinkList<Temp>::swap(LinkList<Temp> & other)
    {
        using std::swap;
        swap(Head, other.Head);
    }


    template<typename Temp>
    void swap(LinkList<Temp> & a, LinkList<Temp> & b)
    {
        a.swap(b);
    }
}

#endif

因为也是初学者，力求直观简单了，可能很多地方不够优化
(＾U＾)ノ~YO

_CodeCAT_
关注
  • 23
    点赞
  • 踩
  • 75
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
单向链表操作类模板实现代码
09-19
单向链表操作类模板实现代码，代码内包含结点类、链表操作类的实现以及主测试函数等；其中链表操作包含结点插入、删除、获取等；
单向链表类模板（全）C++
01-22
含单链表类LinkList.h, 结点类Node.h, 辅助头文件Assistance.h, 测试文件TestLinkList.cpp及TestLinkList.exe
C++数据结构：链表模板
最新发布
KS的博客
02-23 278
链表模板
单链表模板类c++实现
SWC0619的博客
03-23 3638
c++实现单链表
链表 单向链表
weixin_52104711的博客
01-15 128
链表 链表是一种常用的数据结构，创建链表类模板就是创建一个对象的容器，在容器内可以对不同类型的对象进行插入、删除和排序等操作。C++标准模板中有链表类模板，本节将主要实现简单的链表类模板。 单向链表 在介绍类模板之前，先来设计一个简单的单向链表。链表的功能包括向尾节点添加数据、遍历链表中的节点和在链表结束时释放所有节点。例如定义一个链表类。 链表类模板 链表类Clist的一个最大缺陷就是链表不够灵活，其节点只能是CNode类型。让CList能够适应各种类型的节点的最简单方法就是使用类模板。类模板的定义
数据结构与算法之单向链表的设计与实现
m0_49692893的博客
01-01 439
动态数组有个明显的缺点：可能会造成内存空间的大量浪费。能否设计一种数据结构以达到用到多少就申请多少内存？链表可以办到这一点。
数据结构-单向链表的操作（详细思路和实例）
m0_65835264的博客
07-30 964
对单向链表的一系列操作的集合（增删改查等16个函数），用详细的思路、图解、实例、验证，使学习单向链表更加通俗易懂。
c++单链表类模板及其可视化界面
chen666946的博客
07-01 1104
单链表是一种常见的数据结构，用于存储和组织数据。它由一个个节点组成，每个节点包含两部分：数据域和指针域。数据域存储节点中实际的数据，可以是任意类型的数据，例如整数、字符、对象等。指针域则用于指向下一个节点的地址，将多个节点按顺序连接起来形成链表。链式存储：单链表使用指针链接节点，而不需要连续的内存空间。这使得单链表能够灵活地插入和删除节点，不受固定大小的限制。动态大小：单链表的大小可以根据需要动态增长或缩小，不像数组需要预先指定大小并占用连续的内存空间。
C++使用模板实现单链表
12-31
本文实例为大家分享了用模板实现单链表，供大家参考，具体内容如下 话不多说 直接上代码 #include using namespace std; template class CLink; template class Node { friend class CLink; public: /* 构造...
C++使用模板实现单链表（类外实现）
08-26
主要为大家详细介绍了C++使用模板实现单链表的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
单链表的类模板
11-14
单链表的基础类定义，方便引用
单向链表的类模板实现增加、删除、查找和打印
06-18
编写一个单向链表的类模板，分别实现增加、删除、查找和打印操作。目前来说这个方法非常好，很经典。希望对你有所帮助。
模板类实现的通用单链表
11-21
封装自定义单链表类 优点：节点类型不受结构体限制（以结构体实现，未考虑节点为字符串或其他数据类型） 缺点：结构体中必须包含key变量，作为关键字。
单链表（c++类模板实现）
weixin_62802660的博客
09-27 1274
c++类模板实现单链表
用c语言实现单链表的建立、插入与删除
weixin_55702682的博客
03-23 2620
用c语言实现单链表的建立、插入与删除
C++单链表的模板类实现（含文件输入输出）
m0_53917001的博客
10-05 1679
#include <iostream> #include <fstream> #include <typeinfo> #include <iomanip> using namespace::std; template <class T> struct LinkNode {//链表结点定义 T data; LinkNode<T>* link; LinkNode(LinkNode<T>* ptr = NULL) {.
单链表的简单实现，插入和删除
SJCHEN1221的博客
10-04 1357
效果如上 首先我们先定义一个结构 typedef struct Link{ int val;//数据域 struct Link*next;//定义一个next指针 }Link;//别名 第二步，我们创建顺序表 刚开始时，head和pre都指向头指针，创建一个tmp指针赋值x之后，tmp指针指向NULL，pre-&gt;next = tmp,这就把链表链接起来了。 stru...
数据结构—单链表的操作与实现—c++代码（含全部代码）
Initial_Mind的博客
01-21 6063
单链表的操作与实现
实现单链表功能
m0_61548909的博客
11-14 716
用尾插法建立一个单链表，实现对单链表节点的删除、改变其数据域、查看所有的链表节点的数据域。 要求：尾插法建立、节点的删除、改变节点数据域、查看所有节点的数据域。这四个功能分别用四个函数来实现。主函数里只定义链表的头指针。 初次实践 #include <stdio.h>> #include <stdlib.h> #include <stdbool.h> #define ElemType int typedef struct LNode { ElemType
请帮我写一段单链表模板程序
06-08
好的，以下是一个单链表的模板程序，可以根据需要进行修改： ```c++ #include <iostream> using namespace std; //定义单链表节点结构体 template <typename T> struct ListNode { T val; ListNode* next; ListNode(T x) : val(x), next(nullptr) {} }; //定义单链表类 template <typename T> class LinkedList { public: LinkedList() : head(nullptr), tail(nullptr), size(0) {} ~LinkedList() { ListNode<T>* cur = head; while (cur) { ListNode<T>* temp = cur; cur = cur->next; delete temp; } head = tail = nullptr; size = 0; } //在链表尾部添加节点 void add(T x) { ListNode<T>* node = new ListNode<T>(x); if (!head) { head = tail = node; } else { tail->next = node; tail = node; } size++; } //删除链表中所有值为x的节点 void remove(T x) { ListNode<T>* cur = head; ListNode<T>* pre = nullptr; while (cur) { if (cur->val == x) { if (cur == head) { head = head->next; } else if (cur == tail) { tail = pre; tail->next = nullptr; } else { pre->next = cur->next; } ListNode<T>* temp = cur; cur = cur->next; delete temp; size--; } else { pre = cur; cur = cur->next; } } } //打印链表中所有节点的值 void print() { ListNode<T>* cur = head; while (cur) { cout << cur->val << " "; cur = cur->next; } cout << endl; } //返回链表的长度 int getSize() { return size; } private: ListNode<T>* head; ListNode<T>* tail; int size; }; int main() { LinkedList<int> list; list.add(1); list.add(2); list.add(3); list.add(4); list.print(); //输出：1 2 3 4 list.remove(2); list.print(); //输出：1 3 4 cout << "size: " << list.getSize() << endl; //输出：size: 3 return 0; } ``` 该程序定义了一个单链表的模板类，包括添加节点、删除节点、打印链表和返回链表长度等基本操作。其中，ListNode为单链表节点结构体，LinkedList为单链表类，使用模板类实现了支持任意类型的节点值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值