单线性链表的c++实现

最新推荐文章于 2025-12-04 22:00:44 发布
原创 最新推荐文章于 2025-12-04 22:00:44 发布 · 318 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #线性表 #c++ #插入排序 #翻转链表 

#include <cstdlib>
#include <ctime>
#include <iostream>

namespace LINKLIST
{
    template<typename T> class CLinkList;

    template<class T>
    class CLinkNode
    {
        friend class CLinkList<T>;
    private:
        T			m_data;
        CLinkNode	*m_pNext;
    };

    template<class T>
    class CLinkList
    {
    public:
        // 初始化线性列表
        bool InitList();

        // 初始条件：线性表已存在。操作结果：若L为空表，则返回true，否则返回false
        bool Empty();

        // 初始条件：线性表已存在。操作结果：将L重置为空表
        bool Clear();

        // 初始条件：线性表已存在。操作结果：返回L中数据元素个数
        int Length();

        // 初始条件：线性表L已存在，1≤i≤ListLength(L)
        // 操作结果：用e返回第nIndex个数据元素的值,注意i是指位置，第1个位置的数组是从0开始
        bool GetAt(int nIndex, T& e);

        // 初始条件：线性表L已存在,1≤i≤ListLength(L)
        // 操作结果：返回第1个与e满足关系的数据元素的位序
        // 若这样的数据元素不存在，则返回值为0
        int Locate(const T& e);

        // 初始条件：线性表已存在,如果i<1,则插在头部；如果i>m_nLen,则插在尾部
        // 操作结果：第nIndex个位置之前插入新的数据元素e，长度加1 
        bool Insert(int nIndex, const T& e);

        // 初始条件：线性表L已存在
        // 操作结果：在顺序线性表的尾端添加一个元素，长度加1
        bool Pushback(const T& e);

        // 初始条件：线性表已存在，1≤i≤ListLength(L)
        // 操作结果：删除的第nIndex个数据元素，并用e返回其值，L的长度减1
        bool Delete(int nIndex, T& e);

        // 随机产生n个元素的值，建立带表头结点的单链线性表L（头插法）
        bool CreateRandomList(size_t nCount);

        // 显示链表里面的元素
        void DisplayList();

        // 链表元素排序
        void SortList();

        // 反转线性表
        void ReverseList();

        explicit CLinkList()
            : m_pHead(nullptr)
            , m_nLen(0)
        {
        }

        ~CLinkList()
        {
        }

        template<class T>
        bool InitList()
        {
            m_pHead = new CLinkNode<T>;
            if (!m_pHead)
                return false;
            else
            {
                m_pHead->m_pNext = nullptr;
                return true;
            }
        }

        template<class T>
        bool Empty()
        {
            if (m_nLen)
                return false;
            else
                return true;
        }

        template<class T>
        bool Clear()
        {
            if (!m_pHead->m_pNext)
                return true;

            CLinkNode<T> *pNode = m_pHead->m_pNext;
            while (pNode)
            {
                m_pHead->m_pNext = pNode->m_pNext;
                pNode->m_pNext = nullptr;
                pNode = m_pHead->m_pNext;
            }

            m_nLen = 0;
            return true;
        }

        template<class T>
        int Length()
        {
            return m_nLen;
        }

        template<class T>
        bool GetAt(int nIndex, T& e)
        {
            if (!m_nLen)
                return false;
            if ((nIndex >= 1) && (nIndex <= m_nLen))
            {
                CLinkNode<T> *pNode = m_pHead->m_pNext;
                while (--nIndex)
                {
                    pNode = pNode->m_pNext;
                }

                e = pNode->m_data;

                return true;
            }
            return false;
        }

        template<class T>
        int Locate(const T& e)
        {
            int nIndex = 1;
            CLinkNode<T> *pNode = m_pHead->m_pNext;
            while (pNode)
            {
                if (e == pNode->m_data)
                {
                    return nIndex;
                }
                nIndex++;
                pNode = pNode->m_pNext;
            }
            return 0;
        }

        template<class T>
        bool Insert(int nIndex, const T& e)
        {
            // 还没初始化
            if (!m_pHead)
                return false;

            CLinkNode<T> *pNode = nullptr;
            if (nIndex <= 1)
            {
                pNode = new CLinkNode<T>;
                if (pNode)
                {
                    pNode->m_pNext = m_pHead->m_pNext;
                    pNode->m_data = e;
                    m_pHead->m_pNext = pNode;
                    m_nLen++;
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                pNode = m_pHead;
                // --nIndex针对2<=nIndex<=m_nLen的情况
                // pNode针对nIndex>m_nLen的情况，也就是直接加到队尾
                while (--nIndex && pNode->m_pNext)
                {
                    pNode = pNode->m_pNext;
                }

                CLinkNode<T> *pNodeNew = new CLinkNode<T>;
                if (pNodeNew)
                {
                    pNodeNew->m_data = e;
                    pNodeNew->m_pNext = pNode->m_pNext;
                    pNode->m_pNext = pNodeNew;
                    m_nLen++;
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }

        template<class T>
        bool Pushback(const T& e)
        {
            if (!m_pHead)
                return false;

            CLinkNode<T> *pNode = m_pHead;
            while (pNode->m_pNext)
            {
                pNode = pNode->m_pNext;
            }

            CLinkNode<T> *pNodeNew = new CLinkNode<T>;
            if (pNodeNew)
            {
                pNodeNew->m_data = e;
                pNodeNew->m_pNext = nullptr;
                pNode->m_pNext = pNodeNew;
                m_nLen++;
                return true;
            }
            else
            {
                return false;
            }
        }

        template<class T>
        bool Delete(int nIndex, T& e)
        {
            if (!m_pHead)
                return false;

            if ((nIndex >= 1) && (nIndex <= m_nLen))
            {
                CLinkNode<T> *pNode = m_pHead;
                // 找到待删除节点的前一个节点
                while (--nIndex)
                {
                    pNode = pNode->m_pNext;
                }

                CLinkNode<T> *pNext = pNode->m_pNext;
                e = pNext->m_data;
                pNode->m_pNext = pNext->m_pNext;
                delete pNext;
                m_nLen--;
                return true;
            }
            return false;
        }

        // 这个不能配合Delete和Clear使用，因为这里是批量申请内存空间的，不能单个删除
        template<class T>
        bool CreateRandomList(size_t nCount)
        {
            if (m_pHead || nCount < 1)
                return false;

            srand((unsigned int)time(0));
            m_pHead = new CLinkNode<T>;
            if (!m_pHead)
                return false;

            CLinkNode<T> *pNode = nullptr;
            try
            {
                pNode = new CLinkNode<T>[nCount];
            }
            catch (std::exception& e)
            {
                std::cout << "Standard exception: " << e.what() << std::endl;
            }

            m_pHead->m_pNext = pNode;           // 连上头节点
            for (size_t i = 0; i < nCount; i++)
            {
                pNode->m_pNext = pNode + 1;
                pNode->m_data = rand() % 100 + i;
                pNode++;
            }
            (pNode - 1)->m_pNext = nullptr;     // 最后一个节点
            
            m_nLen = nCount;

            return true;
        }

        template<class T>
        void DisplayList()
        {
            if (!m_pHead->m_pNext)
                return;
            int nIndex = 1;
            CLinkNode<T> *pNode = m_pHead->m_pNext;
            while (pNode)
            {
                std::cout << nIndex++ << ": " << pNode->m_data << "\t";
                pNode = pNode->m_pNext;
            }
            std::cout << std::endl;
        }

        template<class T>
        void SortList()
        {
            if (m_nLen < 2)
                return;
            
            CLinkNode<T> *pNewHead = new CLinkNode<T>;              // 新建一个临时表头
            if (!pNewHead)
                return;

            CLinkNode<T> *pNode = m_pHead->m_pNext;
            CLinkNode<T> *pNewNode = nullptr;
            pNewHead->m_pNext = nullptr;
            
            while (m_pHead->m_pNext)                                // 从原链表的前面一个个摘除
            {
                // 从原链表中摘出一个元素
                pNode = m_pHead->m_pNext;
                m_pHead->m_pNext = m_pHead->m_pNext->m_pNext;
                pNode->m_pNext = nullptr;

                pNewNode = pNewHead;                                // pNewNode指向pNewHead的头节点

                do 
                {
                    if (!pNewNode->m_pNext)                         // 找到最后节点处了
                    {
                        pNewNode->m_pNext = pNode;
                        break;
                    }

                    if (pNode->m_data > pNewNode->m_pNext->m_data)
                    {
                        pNewNode = pNewNode->m_pNext;
                        continue;
                    }
                    else
                    {
                        pNode->m_pNext = pNewNode->m_pNext;
                        pNewNode->m_pNext = pNode;
                        break;
                    }
                } while (pNewNode);
            }

            m_pHead->m_pNext = pNewHead->m_pNext;
            delete pNewHead;
        }

        template<class T>
        void ReverseList()
        {
            if (m_nLen < 2)
                return;

            CLinkNode<T> *pFirst = m_pHead->m_pNext;             // 第一个节点
            CLinkNode<T> *pSecond = m_pHead->m_pNext->m_pNext;    // 第二个节点
            CLinkNode<T> *pTemp = nullptr;
            pFirst->m_pNext = nullptr;

            while (pSecond)
            {
                pTemp = pSecond->m_pNext;
                pSecond->m_pNext = pFirst;
                pFirst = pSecond;
                pSecond = pTemp;
            }
            m_pHead->m_pNext = pFirst;
        }

    private:
        CLinkNode<T>    *m_pHead;
        int             m_nLen;
    };
}

代码参考了 http://blog.youkuaiyun.com/freesum/article/details/7355192，不过算法什么的都是自己写的。
单线激光雷达的工作原理
谢谢大家的关注和点赞！这里只有纯纯的知识干货，没有一句废话。希望能实实在在帮到大家～要是觉得有用，别忘了给我点支持哟，你
04-21 1543
单线激光雷达通过单一激光束的水平扫描和时间 / 相位测量，实现二维环境的距离感知，是低成本二维导航的核心传感器。尽管其无法直接提供三维信息，但其可靠性和经济性使其在消费级和工业级场景中广泛应用。随着技术发展，部分单线雷达通过振动镜或 MEMS 微振镜实现微小角度偏转，可近似模拟多线扫描效果，进一步拓展了应用边界。
C++并发编程：线程安全链表
CodeBowl的博客
07-24 2126
最近遇到这么一个问题，一个处理路径的函数，在多线程中被调用，我需要记录某个状态的路径，并在后续当再次处于某个状态时，从链表中将其取出。 为了满足这个需求，用来存储的数据结构要满足： 1. 线程安全：防止在多线程中错误地对一个变量进行修改 2. 便于查询 3. 便于插入、删除 最终想来选择了线程安全的链表，同时备选的队列，但队列不满足便于查询。...
单向链表的操作--C++实现
G1842965496的博客
07-09 251
单线链表的操作（C++实现） #include <iostream> #include <cstdlib> using namespace std; class Node { public: int value; Node *next; }; class Linklist { public: Linklist(); //创建一个单链表 ~Linklist();
单线性链表的创建，遍历以及增删查改
v_yang_guang_v的专栏
04-04 560
#include using namespace std; typedef int datatype; typedef struct LNode { datatype data; struct LNode *next; }LNode,*linklist; //创建链表，带返回值 //LNode * createLinklist(linklist &ll,int n)//ll为指针变量？
【数据结构】C++实现之单线性表
qq_32643313的博客
04-05 546
1、线性表 详见https://blog.youkuaiyun.com/qq_30611601/article/details/79516986 线性表是最基本、最简单、也是最常用的一种数据结构。线性表是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的**（注意，这句话适用大部分线性表，而...
C/C++实现单线链表及基本操作
07-29 749
class CMyList { public: CMyList(void); //向链表中加入一个元素 void Add(int); //从链表中移除一个元素 void Remove(int); //在链表中查找一个元素 int Find(int); //打印链表中的所有元素 void PrintList(); //向链表中插入一个元素 void insert(int,int
单向链表的基本操作
Rong_zhe的博客
08-16 1638
生活中，有一种单线联络的方式;即该工作者只有一个上级和一个下级，不与其他人发生工作联系。这种方式在计算机中也有很好的体现，例如数据结构中的链表。 链表 链表是一种在物理上非连续，非顺序的数据结构，是以若干个节点组成的链式存储形式。 上图是两种形式的链表：单向链表和双向链表，下面主要介绍单向链表。 单向链表 单向链表的每一个节点包含两部分：一部分为存储数据的变量Date，一部分是指向下一个节点的指针next，链表的第一个节点称为头结点，最后一个节点称为尾节点，尾节点的next指针指向空。 与数组按照下标来
c语言-单项链表
WenCoo的博客
12-09 360
一直以来，工作也3年多了，链表这个东西感觉上是比较难的，之前都是做c++，qt什么的，也用不到，有现成的list，自己也是几乎用不到就不去写，现在用c开发，就很常见了，这个一定要学会的，下面是自己写的一个单项链表，还算比较顺手，特此记录，这里要说一下，网上的链表节点查找都是查找某一特定位置的节点信息函数，而不是根据某一值，获取其节点的函数，所以现在我自己做了改良 .c void ftplis...
c语言中链表结点包含什么,单链表
weixin_30776737的博客
05-21 3287
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。中文名单链表外文名Singly Linked List类型数据结构元素实质一种链式存取的数据结构简介地址任意的存储单元存放数据元素建立...
C++单线性链表实现示例与解析
C++实现单链表，一般需要定义节点结构体（class）和对链表的操作方法。这里给出一个简单的示例代码，包含了创建节点、插入节点和打印链表的基本操作： ```cpp #include // 定义节点结构体 struct ListNode { int...
单线性链表演示 - C++源码
06-18
在这个"单线性链表演示 - C++源码"项目中，我们将会深入理解如何在C++编程语言中实现这种数据结构。 首先，单线性链表是由一系列节点组成的数据结构，每个节点包含两个部分：数据域（存储数据）和指针域（指向下一...
结合所学知识编写c++程序，实现以下功能： 1、对含有头结点的单线性链表进行插入操作； 2、插入操作为：1）若链表为空，不进行插入；2）链表不为空进行插入，插入位置为在含有x元素之前；3）若表中无x元素，不进行插入； 3、给出核心代码即可
10-22
在C++中，我们可以使用结构体表示链表节点，并提供一个类来实现链表的基本操作，包括插入。下面是一个简单的实现，核心代码包含链表节点定义和插入函数： ```cpp #include // 链表节点定义 struct ListNode { ...
Leetcode 68 搜索插入位置 | 寻找比目标字母大的最小字母
im_AMBER的博客
12-04 710
你的错误逻辑正确逻辑找到 target 时返回 mid-1找到 target 时，继续向右查找（因为需要「大于」target 的最小字符）target <letters [mid] 时，mid 是候选，需保留，right=mid（左闭右开）或不立即排除 mid循环结束直接返回 letters [0]循环结束后，先判断 left 是否越界：越界则返回 letters [0]，否则返回 letters [left]初始right的取值与「越界判断」不匹配；
欧几里得距离算法-相似度
weixin_45609702的博客
12-04 35
本文介绍了一个计算欧几里得距离的Java方法。该方法接收两个Double数组作为输入，通过计算对应元素差值的平方和再开方，返回两个数组之间的欧几里得距离值。当输入数组长度不一致时，方法会返回0作为默认值。欧几里得距离算法常用于比较两个数组之间的相似度，是数据分析和机器学习中的基础距离度量方法。
dfs|mask^翻转
一个人知道自己为什么而活，他就能够接收任何一种生活
11-30 161
注意到：灯泡状态周期是6。
【剑斩OFFER】算法的暴力美学——数青蛙
最新发布
就业知识博客
12-04 217
力扣1419题：数青蛙
[优选算法专题十.哈希表 ——NO.55~57 两数之和、判定是否互为字符重排、存在重复元素]
2401_83386596的博客
12-03 606
两数之和问题的最优解法采用哈希表实现O(n)时间复杂度，通过存储元素值与下标的映射关系，快速查找互补值。字符重排判定问题通过单哈希数组统计字符出现次数，先加后减并实时校验，确保字符种类和数量完全一致。存在重复元素问题使用哈希集合检测重复元素，遍历数组时检查元素是否已存在于集合中。三种解法均利用哈希结构优化查找效率，将时间复杂度从暴力解法的O(n²)降至O(n)，是典型空间换时间策略的工业级实现。
强化学习[page13]【chapter7】时序差分方法算法介绍
4AM_明朝百晓生
12-01 515
其次，式(7.1)中的TD算法仅能估计给定策略的状态值。尽管如此，本节介绍的TD算法非常基础，对理解本章其他算法至关重要。例如，本章介绍的所有算法都属于时序差分学习的范畴。为简洁起见，式(7.2)常被省略，但必须意识到若缺少该式，算法在数学上将不完整。TD 方法的一个特点是，它在每个时间步更新其值估计，而 MC 方法则要等到回合结束才更新。TD学习的核心思想是基于新获得的信息来修正当前对状态值的估计。因此，TD误差不仅反映两个时间步之间的差异，更重要的是反映了估计值。反映了时间步t与t+1之间的差异。
红包分配算法的严格数学理论与完整实现
12-03 643
红包分配问题可以严格定义为： 定义 1.1（红包分配问题）: 给定总金额 M>0M > 0M>0 和参与人数 n∈N+n \in \mathbb{N}^+n∈N+，分配函数 f:{1,2,...,n}→R+f: \{1, 2, ..., n\} \rightarrow \mathbb{R}^+f:{1,2,...,n}→R+ 需要满足：设 Ω\OmegaΩ 为样本空间，F\mathcal{F}F 为事件域，PPP 为概率测度： 1.2.2 随机变量性质 定义随机变量 XiX_iXi​ 表示第 iii 个人获
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值