C++模板类链表实现

最新推荐文章于 2025-06-03 21:39:46 发布
原创 最新推荐文章于 2025-06-03 21:39:46 发布 · 4.4k 阅读 · 17 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #模板 #c++ #class

模板类链表
编写过程参考了：
http://blog.youkuaiyun.com/qinmusiyan/article/details/39830195
头结点不为空
节点计数从1开始
由于是模板类，声明和定义都放在头文件里
编写注意事项：
每个节点增加时有且只能定义一个分配一个动态内存（new）
时时判断头结点是否为空，如果为NULL，插入时必须在header上进行

#ifndef Linklist_h
#define Linklist_h
#include <iostream>
template <typename T>
struct node
{
    T date;
    node* pNext;
};

template <typename T>
class Linklist
{
public:
    Linklist();
    Linklist(const Linklist<T> &list);
    Linklist<T>& operator= (const Linklist<T> &rhs);
    ~Linklist();
public:
    void headAdd(const T& date); //在头结点插入
    void rearAdd(const T& date); //在尾节点插入
    int size() const; //返回链表长度
    bool isEmpty() const; //判断是否为空
    void print() const; //遍历链表
    T getNElement(int n) const; //返回链表第n个节点值
    void insertNElement(int n,const T& data);//将元素插入在链表的第pos位置上;
    void deleteNElement(int n = 1); //删除第n个节点
    void modifyElement(int n, const T& date); //修改n位置的元素值为x;
    int find(const T& date); //查找x第一次出现的位置，若没有，返回-1;
    void sort(); //对链表元素进行升序排序;  
    void destroy();//销毁链表，将链表成为空链表;

private:
    node<T>* header;
    int length;

};

template <typename T>
Linklist<T>::Linklist() :header(NULL), length(0) {};

template <typename T>
Linklist<T>::Linklist(const Linklist<T> &list) : header(NULL), length(0)
{
    int i = 1;
    while (i <= list.size())
    {
        rearAdd(list.getNElement(i));
        i++;
    }
}

template <typename T>
Linklist<T>& Linklist<T>::operator= (const Linklist<T> &rhs)
{
    if (this == &rhs)
    {
        return *this;
    }
    destroy();
    for (int i = 1; i <= rhs.size(); ++i)
    {
        rearAdd(rhs.getNElement(i));
    }
    return *this;
}

template <typename T>
Linklist<T>::~Linklist()
{
    destroy();
}

template <typename T>
void Linklist<T>::headAdd(const T& date)
{
    node<T> *pnode = new node<T>;
    pnode->date = date;
    pnode->pNext = NULL;
    if (header == NULL)
    {
        header = pnode;
    }
    else
    {
        pnode->pNext = header;
        header = pnode;
    }
    length++;
}

template <typename T>
void Linklist<T>::rearAdd(const T& date)
{
    node<T> *pnode = new node<T>;
    pnode->date = date;
    pnode->pNext = NULL;
    if (header == NULL)
    {
        header = pnode;
    }
    else
    {
        node<T>* rear = header;
        while (rear->pNext != NULL)
        {
            rear = rear->pNext;
        }
        rear->pNext = pnode;        
    }
    length++;
}

template <typename T>
int Linklist<T>::size() const
{
    return length;
}

template <typename T>
bool Linklist<T>::isEmpty() const
{
    return header == NULL;
}

template <typename T>
void Linklist<T>::print() const
{
    node<T> *ptemp = header;
    int count = 0;
    while (ptemp != NULL)
    {
        std::cout << ptemp->date << "\t";
        ptemp = ptemp->pNext;
        count++;
        if (count % 5 == 0)
        {
            std::cout << std::endl;
        }
    }
    std::cout << std::endl;
}

template <typename T>
T Linklist<T>::getNElement(int n) const
{
    if (n < 1 || n > length)
    {
        throw "获得元素位置非法！";
    }
    else
    {
        int i = 1;
        node<T> *ptemp = header;
        while (i++ < n)
        {
            ptemp = ptemp->pNext;
        }
        return ptemp->date;
    }
}

template <typename T>
void Linklist<T>::insertNElement(int n, const T& date)
{
    if (n < 1 || n > length)
    {
        std::cout << "插入元素位置非法！" << std::endl;
    }
    else
    {
        if (n == 1)
        {
            node<T> *ptemp = new node<T>;
            ptemp->date = date;
            ptemp->pNext = header;
            header = ptemp;
        }
        else
        {
            int i = 1;
            node<T> *ptemp = header;
            while (++i < n)
            {
                ptemp = ptemp->pNext;
            }
            node<T> *pinsert = new node<T>;
            pinsert->date = date;
            pinsert->pNext = ptemp->pNext;
            ptemp->pNext = pinsert;
        }
        length++;
    }
    return;
}

template <typename T>
void Linklist<T>::deleteNElement(int n = 1)
{
    if (n < 1 || n > length)
    {
        std::cout << "删除元素位置非法！" << std::endl;
    }
    else
    {
        node<T> *deleteElement;
        if (n == 1)
        {
            deleteElement = header;
            header = header->pNext;
        }
        else
        {
            int i = 1;
            node<T> *ptemp = header;
            while (++i < n)
            {
                ptemp = ptemp->pNext;
            }
            deleteElement = ptemp->pNext;
            ptemp->pNext = deleteElement->pNext;

        }
        delete deleteElement;
        length--;
    }
    return;
}

template <typename T>
void Linklist<T>::modifyElement(int n, const T& date)
{
    if (n < 1 || n > length)
    {
        std::cout << "修改元素位置非法！" << std::endl;
    }
    else
    {
        if (n == 1)
        {
            header->date = date;
        }
        else
        {
            node<T> *ptemp = header;
            int i = 1;
            while (i++ < n)
            {
                ptemp = ptemp->pNext;
            }
            ptemp->date = date;
        }
    }
    return;
}

template <typename T>
int Linklist<T>::find(const T& date)
{
    int i = 1;
    int re = -1;
    node<T> *ptemp = headr;
    while (!ptemp)
    {
        if (ptemp->date == date)
        {
            re = i;
            break;
        }
        i++;
        ptemp = ptemp->pNext;
    }
    return re;
}

template <typename T>
void Linklist<T>::sort()
{
    if (length > 1)
    {
        for (int i = length; i > 0; --i)
        {
            for (int j = 1; j < i; j++)
            {
                T lift = getNElement(j);
                T right = getNElement(j + 1);
                if (lift > right)
                {
                    modifyElement(j, right);
                    modifyElement(j + 1, lift);
                }
            }
        }
    }
    return;
}

template <typename T>
void Linklist<T>::destroy()
{
    while (header != NULL)
    {
        node<T> *ptemp = header;
        header = header->pNext;
        delete ptemp;
    }
    length = 0;
}

#endif

测试运行部分：

#include "Linklist.h"
#include <iostream>
int main()
{
    Linklist<int> link;
    for (int i = 10; i > 0; --i)
    {
        link.rearAdd(i);
    }
    link.print();
    std::cout << link.size() << std::endl;
    Linklist<int> link1(link);
    link1 = link1;
    link1.print();
    link1.deleteNElement(100);
    link1.modifyElement(5, 100);
    link1.insertNElement(3, 50);
    std::cout << link1.size() << std::endl;
    link1.print();

    link1.sort();
    link1.print();
    link1.destroy();
    std::cout << link1.size() << std::endl;
    system("pause");
    return 0;
}
c++模板链表实现
invisible_sky的博客
03-24 2432
简介：主要是利用模板实现链表的操作。模板的使用，使得程序的开发量大大地减少。 可以先定义一个链表LinkList，之后可以定义自己的类了（例如：Student类），使用时就可以这样调用了 LinkList  L； 下面便是链表的实现： LinkList.cpp template struct Node { Type data; struct Node *next; }; templ
链表(C++类模板实现)
zws的博客
07-30 9417
文章目录1. 用C++实现链表2. 代码 1. 用C++实现链表     本文用到C++中的类模板,用类模板的好处就是方便建立任何类型的链表。但类模板这里有个坑就是无法分离编译，具体原因可以百度搜索类模板无法分离编译。最后废话不多说，直接上代码。 2. 代码     sqlist.h文件实现顺序表的声明和定义 #ifndef LINKLIST_H #define LINKLIST_H #include <iostream&
实现一个模板类的链表（c++）
06-03
面向对象程序设计课程作业 1. 请创建一个数据类型为T的链表类模板List，实现以下成员函数： 1） 默认构造函数List()，将该链表初始化为一个空链表（10分） 2） 拷贝构造函数List(const List& list)，根据一个给定的链表构造当前链表（10分） 3） 析构函数~List()，释放链表中的所有节点（10分） 4） Push_back(T e)函数，往链表最末尾插入一个元素为e的节点（10分） 5） operator<<()友元函数，将链表的所有元素按顺序输出（10分） 6） operator=()函数，实现两个链表的赋值操作（10分） 7） operator+()函数，实现两个链表的连接，A=B+C（10分） 2. 请编写main函数，测试该类模板的正确性： 1) 用List模板定义一个List类型的模板类对象int_listB，从键盘读入m个整数，调用Push_back函数将这m个整数依次插入到该链表中；（4分） 2) 用List模板定义一个List类型的模板类对象int_listC，从键盘读入n个整数，调用Push_back函数将这n个整数依次插入到该链表中；（4分） 3) 用List模板定义一个List类型的模板类对象int_listA，调用List的成员函数实现A = B + C；（4分） 4) 用cout直接输出int_listA的所有元素（3分） 5) 用List模板定义List类型的模板类对象double_listA, double_listB, double_listC，重复上述操作。（15分） 3. 输入输出样例： 1) 输入样例 4 12 23 34 45 3 56 67 78 3 1.2 2.3 3.4 4 4.5 5.6 6.7 7.8 2) 输出样例 12 23 34 45 56 67 78 1.2 2.3 3.4 4.5 5.6 6.7 7.8
简单的C++链表类
diedanzhuai8395的博客
09-07 131
#include<iostream> using namespace std; class CList { private: struct Node { int nValue; Node* pNext; }; Node* m_pHead; Node* m...
【c++ 篇】学习笔记之模板--什么是c++模板-函数模板-类模板
最新发布
2401_85061293的博客
06-03 713
程序设计中经常会用到一些程序实体：他们的实现和所完成的功能基本相同，不同的仅仅是所涉及的数据类型不同。而模板正是一种专门处理不同数据类型的机制。模板——是泛型程序设计的基础（泛型generic type——通用类型之意）函数、类以及类继承为程序的代码复用提供了基本手段，还有一种代码复用途径——类属类型（泛型），利用它可以给一段代码设置一些取值为类型的参数（注意：这些参数的值是类型，而不是某类型的数据），通过给这些参数提供一些类型来得到针对不同类型的代码。
链表模板
qq_40921866的博客
12-23 173
#include<iostream> #include<stdio.h> #include<string.h> #include<algorithm> using namespace std; typedef struct Lnode { int data; Lnode *next; } Lnode,*...
c++实现链式表的类模板
chczy1的博客
10-16 996
在写链表反转的时候很苦恼，感谢这位博主的图http://blog.youkuaiyun.com/u013271921/article/details/46382345 然后自己画了几遍，终于是理解了 /* 类模板双向链表，通过一个节点类node和一个链表类chlist来实现，node中包含前驱指针pr,后继指针nx，和数据域data，并且data可接受任意类型的数据 链表类chlist包含逆序创建链表
C++模板类链表实现：添删改查操作详解
- C++模板类允许用户创建一个通用的类，这个类可以用于多种数据类型。通过在类定义中使用 `template <typename T>`，我们可以创建一个类型为T的模板类，其中T代表任意的数据类型。 2. **链表的数据结构**: - 链表...
C++利用链表模板类实现简易队列
08-26
C++利用链表模板类实现简易队列 本文主要为大家详细介绍了C++利用链表模板类实现一个简易队列，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。 知识点一：链表模板类 在C++中，链表是一种常用的数据结构，...
C++模板类实现链表
allensu374125056的博客
04-23 1062
注意 链表中要包含Node的结构体，用来把节点放进去 只有出现Node就要加<T> ,不然会报错 有类模板的重新编译记得清空再重新生成 清除链表时使用的循环清空头结点的思想需要记得（C语言中一样循环调用清除0号元素也可以） Debug和Release编译不同，一步一步执行时顺序不一样，不知道为啥了，不过不重要，结果一样 自己写的清空函数 template <typename ...
C++实现链表，模板类
07-06
C++实现的模板链表类，没有用到STL的list，是用指针实现的。
用c++类模板，实现的单链表基本操作
05-14
#include "stdafx.h" #include #include using namespace std; template struct LNode { T data; LNode *next; }; template class LinkList { public: LinkList(){L = 0;}//构造函数 ~LinkList();//析构函数，销毁单链表 void CreateList_L(int n);//构造单链表 bool IsEmpty() const{return L->next == 0;}//判断单链表是否为空 int GetElem_L(int i,T &e) const;//当第i个元素存在时，其值赋给e int ListInsert_L(int i,T &e);//在第i个位置插入元素e ……………………
链表数据结构的C++实现：类模板实现线性表的链式存储
仅以此博客记录日常学习工作中所思所得，水平有限，难登大雅，万望海涵。
04-07 1223
C++类模板实现链表数据结构。
C++模板类实现单链表
Nou_Camp的博客
04-08 4854
c++模板类实现单链表#include<iostream> using namespace std; #include<assert.h> #include<string> template<class T> struct LinkNode { LinkNode<T>* _next; T _data; LinkNode(const T& x) :_data(x
C++链表模板
长风破浪
05-19 427
【代码】C++链表模板。
C++单链表的模板类实现（含文件输入输出）
m0_53917001的博客
10-05 1999
#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) {.
C++模板实现链表
luanzheng_365的博客
03-19 589
单链表是一种非常基本的数据结构. 虽然C++ STL中已经存在功能强大的List,但我们通过自己实现单链表,对于锻炼C++的基本功,加深对编程的理解与认识还是很有益的. 另外,自己的代码,在使用过程中更容易和敢于修改,更容易灵活定制自己的需求. 在实现单链表的过程中,选用模板,可以使得链表得到极大的灵活性.代码的可复用性大大增强. 核心代码分析解读: 1. 定义存放单个节点的数据结构: T可以
6.C++ 双向循环链表类模版实现
抵抗时间扭曲，坚持做一件有意义的事
02-24 1112
在上章4.C++ 图解单向链表类模板、iterator迭代器类模版实现_抵抗时间扭曲，坚持做一件有意义的事-优快云博客_链表类模板的实现 我们学习了单链表,所以本章来学习双向循环链表 我们在上个文章代码上进行修改, 由于双向循环链表在我们之前学的单链表上相对于较为复杂,所以需要注意的细节如下所示. 1.插入某个节点流程 如下图所示: 对应代码如下所示: /*插入一个新的节点*/ bool insert(int i, const T& value) { .
模板实现链表
weixin_45396618的博客
09-09 284
#include <iostream> #include <stdexcept> #include <cstring> using namespace std; //双链表 template<typename T> class List{//列表 private: //双向链表结点 class Node{ public: T m_elem; //结点元素 Node *m_prev; //前结点 Node *m_next; //下一个节点
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值