数据结构之 单链表 模板类

最新推荐文章于 2022-09-27 18:01:29 发布
最新推荐文章于 2022-09-27 18:01:29 发布
阅读量331 收藏 1
点赞数
分类专栏： 工作上的学习 文章标签： 数据结构 单链表 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012925231/article/details/78359505
版权

2017 10 25更新：
写完了的 “单链表模板类”如下图所示（还差一个按照规则升序或者降序添加数据的函数insertSeq，明天可以完成—-26号写完了）

#include<iostream>

#ifndef _H_MYCHAIN_H
#define _H_MYCHAIN_H

template<class T>
class mychain;

template<class T>
struct snode
{
    struct snode<T>* next;
    T val;
};

template<class T>
class mychain
{
public:
    /构造函数与析构函数
    mychain(void);////默认构造函数
    mychain(const mychain<T>& otherChain);////拷贝构造函数
    ~mychain();////析构函数

    ////增
    void addHead(const T val);////头插
    int insert(const int pos, const T val);////中间插入数据，成功则返回插入位置的索引，从0开始，失败则返回-1，如果索引超出范围，也返回-1
    int insertSeq(const T val, bool isAscend);///让元素按照升序或者降序插入到满足条件的第一个元素后面，返回插入位置的索引
    int push_back(const T val);////尾插数据，返回插入的索引

    /////删
    int del(const int pos);////删除指定索引的元素，返回被删除的元素的索引，失败则返回-1
    int remove(T val);////移除指定值得第一个元素，返回元素原来在的索引，不存在则返回-1
    int removeAllVal(const T val);////移除所有的指定数值的元素，返回移除的个数
    bool clear(void);

    /////改
    int modify(const int pos, const T val_new);////修改指定索引处的数值为val_new，返回替换位置的索引，如果索引不存在则返回-1
    int replace(const T val_old, const T val_new);////替换第一个找到的指定数值的元素为val_new，返回其索引，如果指定数值不存在，则返回-1
    int replaceAll(const T val_old, const T val_new);////替换所有的指定数值为val_new，返回替换的个数

    ////查
    int find(const T val);////查找指定数值的元素的索引，不存在则返回-1
    bool getAt(const int pos, T& val);////获取指定索引的元素的数值，存放在val引用中，不存在则返回false

    ////为了重载输出操作符
    void output(std::ostream& out);

    /////想要实现但是没有实现的
    //friend std::ostream& operator<<(std::ostream, const mychain<T>& chain);
    //struct snode<T>* getPtrByIndex(int pos);
    //struct snode<T>* getPtrByVal(const T val);

private:
    struct snode<T>* m_pHead;
};

template<class T>
std::ostream& operator<<(std::ostream& out, mychain<T>& mc);

#endif

/////构造函数与析构函数
template<class T>
mychain<T>::mychain(void)////默认构造函数
{
    m_pHead = NULL;
}

template<class T>
mychain<T>::mychain(const mychain<T>& otherChain)////拷贝构造函数
{
    if(NULL  == otherChain.m_pHead)
    {
        m_pHead = NULL;
        return;
    }
    ////以下是被拷贝对象不为空的情况
    bool isFirst = true;
    struct snode<T> *p_pre = NULL;
    struct snode<T> *p = otherChain.m_pHead;
    while (NULL != p)
    {
        if(isFirst)
        {
            m_pHead = new struct snode<T>;
            m_pHead->val = p->val;
            p_pre = m_pHead;
            isFirst = false;
        }
        else
        {
            p_pre->next =  new struct snode<T>;
            p_pre = p_pre->next;
            p_pre->val = p->val;
        }
        p = p->next;
    }
    p_pre->next = NULL;
}

template<class T>
mychain<T>::~mychain()////析构函数
{
    if(NULL != m_pHead)
    {
        struct snode<T>* p = m_pHead;
        m_pHead = NULL;
        struct snode<T>* p_nxt;
        while (NULL != p)
        {
            p_nxt = p->next;
            delete p;
            p = p_nxt;
        }
    }
}

////增
template<class T>
void mychain<T>::addHead(const T val)////头插
{
    struct snode<T>* p = new struct snode<T>;
    p->val = val;
    p->next = m_pHead;
    m_pHead = p;
    p = NULL;////防止野指针（感觉其实没必要）
}

template<class T>
int mychain<T>::insert(const int pos, const T val)////中间插入数据，原来的位置的数据向后移动，成功则返回插入位置的索引，从0开始，失败则返回-1，如果索引超出范围，也返回-1
{
    if(0 == pos)/////要求的索引为0的时候，不管原来的链表是不是为空，都直接头插
    {
        addHead(val);
        return 0;
    }
    else//////但是如果不是在0的位置的话，那就需要考察是不是超出索引了
    {
        struct snode<T>* p = m_pHead;
        for(int ii = 0;(ii < pos-1) && (NULL != p); ii++)
        {
            p = p->next;
        }
        if(NULL != p)
        {
            struct snode<T>* p_next = p->next;
            p->next = new struct snode<T>;
            p = p->next;
            p->val = val;
            p->next = p_next;
            return pos;
        }
        else
        {
            return -1;
        }
    }
}

template<class T>
int mychain<T>::insertSeq(const T val, bool isAscend)
{
    if (NULL == m_pHead)
    {
        addHead(val);
        return 0;
    }
    if ((val < m_pHead->val && isAscend)||(!isAscend && val > m_pHead->val))
    {
        addHead(val);
        return 0;
    }
    struct snode<T>* p = m_pHead;
    struct snode<T>* p_nxt = NULL;
    int cnt = 0;
    while (NULL != p)
    {
        cnt = cnt + 1;
        p_nxt = p->next;
        if (NULL != p_nxt)
        {
            if ( (val > p->val && val <= p_nxt->val && isAscend) || 
                (val < p->val && val >= p_nxt->val && !isAscend))
            {
                break;
            }
        }
        else
        {
            break;
        }
        p = p_nxt;
    }
    p->next = new struct snode<T>;
    p = p->next;
    p->val = val;
    p->next = p_nxt;
    return cnt;
}

template<class T>
int mychain<T>::push_back(const T val)////尾插数据，返回插入的索引
{
    if (NULL == m_pHead)
    {
        addHead(val);
        return 0;////头插的索引为0
    }
    /////下面是非头插的情况
    struct snode<T>* p = m_pHead;
    int cnt = 1;
    while(NULL != p->next)
    {
        cnt = cnt + 1;
        p = p->next;
    }
    p->next = new struct snode<T>;
    p = p->next;
    p->val = val;
    p->next = NULL;
    return cnt;
}

/////删
template<class T>
int mychain<T>::del(const int pos)////删除指定索引的元素，返回被删除的元素的索引，失败则返回-1
{
    if(0 == pos)
    {
        if(NULL == m_pHead)
        {
            return -1;
        }
        else
        {
            struct snode<T>* p = m_pHead->next;
            delete m_pHead;
            m_pHead = p;
        }
    }
    else
    {
        struct snode<T>* p = m_pHead;
        for(int ii = 0; (ii < pos - 1) && (NULL != p); ii ++)
        {
            p = p->next;
        }
        if(NULL == p)
        {
            return -1;/////前面的元素都不存在
        }
        else
        {
            if(NULL == p->next)
            {
                return -1;//////想要被删的元素不存在
            }
            else
            {
                struct snode<T>* p_del = p->next;
                p->next = p_del->next;
                delete p_del;
            }
        }
    }
    return pos;
}

template<class T>
int mychain<T>::remove(T val)////移除指定值得第一个元素，返回元素原来在的索引，不存在则返回-1
{
    struct snode<T>* p = m_pHead;
    int cnt = 0;
    if (val == p->val)
    {
        m_pHead = m_pHead->next;
        delete p;
        return cnt;
    }
    struct snode<T>* p_nxt = NULL;
    while (NULL != p)
    {
        p_nxt = p->next;
        cnt = cnt + 1;
        if (NULL != p_nxt)
        {
            if (val == p_nxt->val)
            {
                p->next = p_nxt->next;
                delete p_nxt;
                p_nxt = NULL;
                return cnt;
            }
        }
        p = p_nxt;
    }
    return -1;
}

template<class T>
int mychain<T>::removeAllVal(const T val)////移除所有的指定数值的元素，返回移除的个数
{
    struct snode<T>* p = m_pHead;
    int cnt = 0;////删除的元素数目
    struct snode<T>* p_nxt = NULL;
    while (NULL != p)
    {
        p_nxt = p->next;
        if (NULL != p_nxt)
        {
            if (val == p_nxt->val)
            {
                cnt = cnt + 1;
                p->next = p_nxt->next;
                delete p_nxt;
                continue;
            }
        }
        p = p_nxt;
    }
    p = m_pHead;
    if (val == m_pHead->val)
    {
        m_pHead = m_pHead->next;
        delete p;
        cnt = cnt + 1;
    }
    return cnt;
}

template<class T>
bool mychain<T>::clear(void)
{
    if(NULL != m_pHead)
    {
        struct snode<T>* p = m_pHead;
        m_pHead = NULL;
        struct snode<T>* p_nxt;
        while (NULL != p)
        {
            p_nxt = p->next;
            delete p;
            p = p_nxt;
        }
    }
}

/////改
template<class T>
int mychain<T>::modify(const int pos, const T val_new)////修改指定索引处的数值为val_new，返回替换位置的索引，如果索引不存在则返回-1
{
    struct snode<T>* p = m_pHead;
    for (int ii = 0; (ii < pos) && (NULL != p); ii++)
    {
        p = p->next;
    }
    if(NULL == p)
    {
        return -1;
    }
    else
    {
        p->val = val_new;
        return pos;
    }
}

template<class T>
int mychain<T>::replace(const T val_old, const T val_new)////替换第一个找到的指定数值的元素为val_new，返回其索引，如果指定数值不存在，则返回-1
{
    struct snode<T>* p = m_pHead;
    int cnt = 0;
    while (NULL != p)
    {
        if (val_old == p->val)
        {
            p->val = val_new;
            return cnt;
        }
        p = p->next;
        cnt = cnt + 1;
    }
    return -1;
}

template<class T>
int mychain<T>::replaceAll(const T val_old, const T val_new)////替换所有的指定数值为val_new，返回替换的个数
{
    struct snode<T>* p = m_pHead;
    int cnt = 0;
    while (NULL != p)
    {
        if (val_old == p->val)
        {
            p->val = val_new;
            cnt = cnt + 1;
        }
        p = p->next;
    }
    return cnt;
}

////查

template<class T>
int mychain<T>::find(const T val)////查找指定数值的元素的索引，不存在则返回-1。索引从零开始计算
{
    struct snode<T>* p = m_pHead;
    int cnt = 0;
    while (NULL != p)
    {
        if(val == p->val)
        {
            return cnt;
        }
        cnt = cnt + 1;
        p = p->next;
    }
    return -1;
}

template<class T>
bool mychain<T>::getAt(const int pos, T& val)////获取指定索引的元素的数值，存放在val引用中，不存在则返回false
{
    struct snode<T>* p = m_pHead;
    for (int ii = 0; (ii < pos) && (NULL != p); ii++)
    {
        p = p->next;
    }
    if(NULL != p)
    {
        val = p->val;
        return true;
    }
    return false;
}

////为了重载输出操作符

template<class T>
void mychain<T>::output(std::ostream& out)
{
    struct snode<T>* p = m_pHead;
    while (NULL != p)
    {
        out<<p->val <<" ";
        p = p->next;
    }
    out<<std::endl;
}

template<class T>
std::ostream& operator<<(std::ostream& out, mychain<T>& mc)
{
    mc.output(out);
    return out;
}

下面是该模板类的测试函数，针对每一个函数进行测试

#include "mychain.cpp"
#include<iostream>

void main(void)
{
    mychain<int> mc;
    for (int ii = 0; ii < 10; ii++)
    {
        if(ii%2 == 0)
        {
            mc.push_back(ii);
        }
        else
        {
            mc.addHead(ii);
        }
    }
    std::cout<<mc<<std::endl;

    mc.insert(3,8);
    mc.insert(1,4);
    mc.insert(3,8);
    std::cout<<mc<<std::endl;

    mc.replaceAll(8,4);
    std::cout<<mc<<std::endl;

    mc.removeAllVal(4);
    std::cout<<mc<<std::endl;

    mychain<int> mc1;
    for (int ii = 0; ii < 10; ii++)
    {
        std::cout<<mc1.insertSeq(ii,false)<<"  ";
    }
    std::cout<<std::endl;
    std::cout<<mc1<<std::endl;



    std::system("pause");
}
u012925231
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——单链表模板类
razorEdge的博客
09-24 906
数据结构相关笔记整理（一） 这里主要是整理自己在学习数据结构的时候的笔记，这篇博客主要整理单链表的模板类附带几个内置函数的测试，新手上路，多多包涵，发现错误及时交流..... 第一部分是主类代码：(直接贴了哈~~) #include #include #include "linearList.h" using namespace std; //定义单链表的模板类 t
C++数据结构之单链表实现
09-18
在IT领域，数据结构是计算机科学的基础，而链表作为一种重要的数据结构，广泛应用于各种算法和程序设计中。本文将详细讲解如何使用C++来实现一个单链表，并涵盖其核心功能，包括创建、遍历、反转、插入、取值、修改...
数据结构—单链表(模板类)
weixin_30600503的博客
04-19 125
链表概念--链表是一种线性表，但是并不是顺序存储，而是每个节点里面存储着下一个节点的指针，把存储数据元素的数据串链起来 单链表的实现 1 #include<iostream> 2 #include<assert.h> 3 using namespace std; 4 5 template <class T> ...
单链表模板类
linux_Allen的博客
05-01 586
单链表模板类 List.h 接口类 LinkList.h 单链表类 在单链表中必然需要定义一个头节点来指向链表的第一个元素， struct Node :public Object { T value; Node* next; }; mutable Node m_header; 这样直接定义会有一个问题，头节点的构造会调用T类的构造函数，这显然时不需要的，解...
单链表的模板类
低调走过
07-18 2670
////////////////////////////带附加头结点的单链表的类定义/////////////////////////////////////// template //定义在头文件"LinkedList.h"中 struct LinkNode //链表结点类的定义 { T data; //数据域 LinkNode *link; //链指针域 LinkNode(LinkNode *ptr = NULL)
826. 单链表 +数组模拟单链表
qq_45638271的博客
08-13 207
实现一个单链表，链表初始为空，支持三种操作： 向链表头插入一个数； 删除第 k 个插入的数后面的数； 在第 k 个插入的数后插入一个数。 现在要对该链表进行 M 次操作，进行完所有操作后，从头到尾输出整个链表。 注意:题目中第 k 个插入的数并不是指当前链表的第 k 个数。例如操作过程中一共插入了 n 个数，则按照插入的时间顺序，这 n 个数依次为：第 1 个插入的数，第 2 个插入的数，…第 n 个插入的数。 输入格式 第一行包含整数 M，表示操作次数。 接下来 M 行，每行包含一个操作命令，操作命令可能
学生信息单链表模板类
04-14
理解并掌握单链表模板类的设计和实现，不仅可以帮助提升编程技能，还能为其他高级数据结构和算法的学习打下坚实的基础。在实际应用中，链表常用于动态内存管理、文件系统、缓存管理等领域。因此，花时间深入学习和...
学生系统单链表模板类
04-14
### 学生系统单链表模板类 #### 概述 本项目主要通过单链表的方式实现了学生信息的管理功能，其中包括对学生数据的增删查改等操作。使用C++语言编写，通过定义一系列的数据结构与算法来实现学生信息的有效管理和...
数据结构单链表
11-04
单链表. template class LinkList { public: LinkList(); //无参构造函数，建立只有头结点的空链表 LinkList(T a[], int n); //有参构造函数，建立由n个元素的单链表 ~LinkList(); //析构函数 int Length(); //...
单链表_单向链表的类模板_
10-03
单向链表是一种基本的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在C++中，我们可以使用类模板来创建一个通用的单向链表，以便存储不同类型的数据。下面我们将详细探讨如何设计这样一...
模板类实现的通用单链表
11-21
封装自定义单链表类 优点：节点类型不受结构体限制（以结构体实现，未考虑节点为字符串或其他数据类型） 缺点：结构体中必须包含key变量，作为关键字。
单链表的类模板定义与实现
10-31
就是一个单链表的定义与实现，对于学数据结构会有帮助的
数据结构模板之二：单链表
Gsdxiaohei
06-24 468
①基本定义链表即线性表的链式存储结构。
数据结构模版----单链表实现方式总结
热门推荐
OSKernelLAB(gatieme)
01-13 1万+
前面我们提供了四种方式实现的单链表，有带头结点的不带头结点的，而单链表的结构体定义也有两种方式，那么这些实现方式，到底有什么区别呢，为什么会出现这么多种实现方式呢，下面我们就来细细体会 一 单链表结构体的实现区别 首先我们对比一下，单链表结构体 ①带length标识的单链表结构体 typedef struct LinkList { LinkListNode *m_head; /
单链表类型模板
wangxiaoxiao0108的博客
05-07 1530
单链表类型模板 单链表类模板，本例作为一个头文件。单链表的结点采用类，与结点有关的基本操作都作为结点类的成员函数。对链表整体的操作则作为链表类的成员函数，包括清空链表、查找数据、计算单链表长度、打印链表数据、向前生成链表、向后生成链表、按升序生成链表等等。 "Ex7_5.h" #include<iostream> using namespace std; //首先看结点组织，采用...
单链表的模版类及其各种操作
行走的天马
03-15 928
/*********************链表节点定义******************************************/ template struct LinkNode{          //链表节点 T data;    //数据域 LinkNode* link; //指针域 LinkNode(LinkNode* ptr=NULL){link=ptr;}  
单链表（c++类模板实现）
最新发布
weixin_62802660的博客
09-27 1390
c++类模板实现单链表
单链表模板类c++实现
SWC0619的博客
03-23 3721
c++实现单链表
模板实现的单链表数据结构详解
通过模板类的方式，讲解了如何构建一个灵活的链表数据结构，允许存储不同类型的数据。 单链表是一种基本的数据结构，每个元素由结点构成，结点包含数据和指向下一个结点的指针。这种结构允许元素在内存中不连续存储...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值