单链表（c++类模板实现）

最新推荐文章于 2023-06-02 11:07:06 发布
最新推荐文章于 2023-06-02 11:07:06 发布
阅读量1.3k 收藏 6
点赞数 1
分类专栏： c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62802660/article/details/127075758
版权

后续会写详细的实现过程，就是功能4，和功能13测试的时候还有点问题，不过会改进的

定义在“LinkedList.h”

#include <iostream>
using namespace std;
# ifndef INCLUDE_LINKEDLIST_H_
# define INCLUDE_LINKEDLIST_H_
template  <class T>
struct LinkNode //链表节点类的定义 
{
    T data;       //数据域 
    LinkNode<T>*link;//链指针域
        LinKNode(LinkNode<T>*ptr=NULL) 
    {
        link=ptr;//仅初始化指针成员的构造函数 
    }
    LinkNode(const T&item,LinkNode<T>*ptr=NULL)
    {
        data=item;
        link=ptr;//初始化数据与指针成员的构造函数 
    }
 } ;
 template <class T>
 class List{//单链表类定义，不用继承也可以实现 
 
     public:
          List() {
         first = new LinkNode<T>(0,NULL); 
     }
     List(const T&x) 
     {
         first=new LinkNode<T>(x) ;    //带参数的构造函数 
     }
     List(List<T>&L) ;//复制构造函数                                         语法 
     ~List() {
     makeEmpty(); //析构函数 
     
     }
     void makeEmpty();
     int Length()const;  
     LinkNode<T>*getHead()const                                        //类内定义的方式 
     {
     return first;                                                   //  为什么要用常函数     
     } 
     void setHead(LinkNode<T>*p) //设置附加头结点地址 
     {
         first=p;
     }
     LinkNode<T>*Search(T x) ;//搜索含数据x的元素 
     LinkNode<T>*Locate(int i);//搜索第i个元素的地址 
     T*getData(int i); //取出第i个元素的数值 
     void setData(int i,T&x);//用x修改i位置的数值 
     bool Insert(int i,T&x) ;//在第i个元素后插入x元素 
     bool Remove(int i,T&x) ;//删除第i个元素，x返回该元素的值 
     bool IsEmpty()const{                                                   //这里用常函数到底是用来干嘛的 
     //判断链表是否为空
      return first->link==NULL ?true:false; 
     }
     bool IsFull()const
     {
         return false;//                                                        好家伙，直接返回错误了，还判断个鬼啊 
     }
     void Sort();//排序函数 
     void createlist(T end);
     void output() ;//输出
    List<T>&operator=( List<T>&L) ;//重载函数，赋值 
    protected:
     LinkNode<T> *first; 
 };
  
  template <class T>//复制构造函数 
  List<T>::List(List<T>&L) 
  {
      T value;
      LinkNode<T>*srcptr=L.getHead;//被复制表的附加头结点地址
      LinkNode<T>*desptr=first=new LinkNode<T>;  
      while(srcptr->link!=NULL)//逐个节点复制
      {
          value=srcptr->link->data;
          desptr->link=new LinkNode<T> (value);
          desptr=desptr->link;
          srcptr=srcptr->link;
                 } 
  };
  template <class T>
  void List<T>::makeEmpty()//将链表置为空 
  {
      LinkNode<T>*q;  //建 
      while(first->link!=NULL) 
      {
          //当链表不为空时，删除节点
          q=first->link;//指 
          first->link=q->link;//摘
          delete q; //删 
      }
  }; 
  
  
  template <class T>
  int List<T>::Length()const//计算带附加节点的链表长度 
  {
      LinkNode<T>*p=first->link;//从头节点开始 
      int count=0;//计数 
      while(p!=NULL) 
      {
          p=p->link;//移动 
          count++;//计数 
      }
      return count; 
  }
   template<class T>
   LinkNode<T>*List<T>::Search(T x)                                  //有点不太清除这里的函数类型选择 
   {  
     
    LinkNode<T>*current=first->link;//从头开始找
    while(current!=NULL) 
    {
        if(current->data==x)
        {
            cout<<"该元素存在于单链表中"<<endl;
            break; 
        }
        else
        {
            current=current->link;//后移 
         } 
         
        
    }     
    
             cout<<"不存在该元素！"<<endl;
         return NULL;
   };
   template<class T>
   LinkNode<T>*List<T>::Locate(int i) //定位函数
   {
       //合理性判断
       if(i<0)                                       //总觉得这合理性少了点什么 
       {
           return NULL;
       }
       LinkNode<T>*current=first;
       int k=0;
       while(current!=NULL&&k<i)//超出判断 
       {
           k++;
           current=current->link;//指针移动 
       }
       return current; 
    } ;
    
    template<class T>
    T*List<T>::getData(int i)
    {
        if(i<0)
        {
            return NULL;
        }
        LinkNode<T>*current=Locate(i);//定位
        if(current==NULL) 
        return NULL;
        else 
        {
            cout<<current->data<<endl;
        return &current->data;//取出数值 
    }
        
    };
    template<class T>//对第I个1位置进行赋值的函数 
    void List<T>::setData(int i,T&x) 
    {
        if(i<=0)
        {
                 cout<<"错误！"<<endl;                                                                                   //return NULL
        }
        LinkNode<T>*current=Locate(i) ;
        if(current==NULL)
        cout<<"错误！"<<endl;                                                                             //return NULL 
        else
        current->data=x;
        
     } ;
   template<class T>
   bool List<T>::Insert(int i,T&x) //将x元素插入到第i位之后 
   {
        LinkNode<T>*current=Locate(i);                                                //怎么这里不严谨了不检查了，我就很奇怪 
       //设置查找指针
       if(current==NULL) 
       return false;
       LinkNode<T>*newNode=new LinkNode<T>(x) ;
       if(newNode==NULL)
       {
           cerr<<"储存分配错误！" <<endl;
           exit(1);//退出程序 
       }
       newNode->link=current->link;
       current->link=newNode;
       return true;// x先下后上 
   }; 
   template <class T> 
   bool List<T>::Remove(int i,T&x)
   {
                                                           //这也不用检查？！
        LinkNode<T>*current=Locate(i-1)    ;//删除i位置，首先要找到它前面的位置
        if(current==NULL||current->link==NULL)    
        {
            return false;                                    }
            LinkNode<T>*del=current->link;//摘下删除节点 
            current->link=del->link;
            x=del->data;
            delete del;
            return true;                                             
   };
   
   
   template<class T>
   void List<T>::Sort()                                //直接忽略了，你确定???什么鬼教材 
   {
          LinkNode<T>*p=first;
          for(int i=0;i<Length();i++)
          {
              p=Locate(1);
              for(int j=1;j<=Length()-i;j++)
              {
                  if(p->data>(p->link->data))
                  {
                      T n;
                      p->data=n;
                      n=p->link->data;
                      p->link->data=n;//冒泡排序法 
                      
                  }
                  p=p->link;//向后移动 
              }
              
          }
       cout<<"排序后的链表为" <<endl;
       while(p->link!=NULL)
       {
           cout<<p->data;
           p=p->link;
       }
          };
   template <class T>
   void List<T>::createlist( T end) 
   {
       LinkNode<T>*newNode;
       T val;
       first=new LinkNode<T>(0,NULL);
       if(first==NULL)
       {
           cerr<<"储存分配错误！" <<endl;
           exit(1);
       }
       cin>>val;
       while(val!=end)
       {
           newNode=new LinkNode<T>(val);
           if(newNode==NULL)
           {
               cerr<<"储存分配错误"<<endl;
               exit(1) ;
           }
           newNode->link=first->link;
           first->link=newNode;
           cin>>val;
       }
       
   };
   template<class T>
   void List<T>::output() 
   {
       LinkNode<T>*current=first->link;
       while(current!=NULL) 
       {
           cout<<current->data<<endl;
           current=current->link;//移动 
       }
   };
   template<class T>
  List<T>&List<T>::operator=( List<T> & L) 
   {
       //重载函数：赋值操作
       T value;
       LinkNode<T>*srcptr=L.getHead;//被复制表的附加头节点地址
       LinkNode<T>*destptr=first=new LinkNode<T>;
       while(srcptr->link!=NULL) 
       {
           //逐个节点复制
           value=srcptr->link->data;
           destptr->link=new LinkNode<T>(value) ;
           destptr=destptr->link;
           srcptr=srcptr->link;
       }
       destptr->link=NULL;
       return *this;//返回操作对象地址 
   };
   #endif
   

定义在.cpp文件中

#include <iostream>
#include"LinkedList.h"
typedef int T;
using namespace std;
int main()
   {
       cout<<"---------------------单链表------------------"<<endl;
       cout<<"请输入单链表的值并以0为结束标志"<<endl;
   List<int>susu;
   susu.createlist(0);
       cout<<"------------单链表已经创建成功----------------" <<endl;
    susu.output();
    cout<<"-------------请输入要执行的操作---------------"<<endl;
        cout<<"1:计算链表长度              2：将链表置为空             3：返回附加头结点的地址" <<endl;
    cout<<"4:设置附加头节点的地址      5：搜索是否含x元素           6：搜索含第i个元素的地址"<<endl;
    cout<<"7:取出第i个元素的值和地址          8：用x修改第i个元素的值     9：在第i个元素后插入元素x"<<endl;
    cout<<"10:删除第i个元素，返回该元素的值     11：判断是否为空表      12：判断是否为满表"<<endl;
    cout<<"13：对链表进行排序   14：输出当前链表的值"<<endl;
         

    int a;
    cin>>a;
    switch(a) 
    {
        case 1:
           cout<<susu.Length()<<endl;
           break;
           case 2:
               susu.makeEmpty();
               cout<<"置空成功"<<endl;
               break;
               case 3:
                   cout<<susu.getHead()<<endl;
                   break;
                   case 4:
                       cout<<"请输入附加头节点的地址"<<endl; 
                       LinkNode<T>*lo;
                       susu.setHead(lo);
                   break;
                   case 5:
                       int b;
                       cout<<"请输入元素x"<<endl;
                       cin>>b;
                       susu.Search(b) ;
                       break;
                       case    6:
                           cout<<"请输入要查询地址的元素"<<endl;
                           int c;
                           cin>>c;
                           susu.getData(c);
                           break;
                           case 7:
                               cout<<"请输入i"<<endl;
                               int d;
                               cin>>d;
                               cout<<susu.getData(d) <<endl;
                               break;
                        case 8:cout<<"请输入对应的x和i值" ;
                        int e;
                        T f;
                        cin>>e>>f;
                        susu.setData(e,f); 
                        cout<<"修改后的链表为"<<endl;
                        susu.output();
                        break;
                        case 9:
                            cout<<"请输入对应的i和x值"<<endl;
                            int g;
                            T h;
                            cin>>g>>h;
                            susu.Insert(g,h);
                            cout<<"插入后的链表为"<<endl;
                            susu.output();
                            break;
                            case 10:
                            cout<<"请输入对应的i" ;
                            int k;
                            T o;
                            cin>>k;
                            susu.Remove(k,o) ;
                            cout<<"删除的元素为"<<o<<endl;
                            
                            break;
                            case 11:
                            susu.IsEmpty();
                            if(susu.IsEmpty()!=0) 
                            {
                                cout<<"链表为空"; 
                            }
                            else
                            {
                                cout<<"链表非空"<<endl;
                            }
                            break; 
                            case 12:
                                susu.IsFull();
                                if(susu.IsFull()!=0) 
                            {
                                cout<<"链表已满"; 
                            }
                            else
                            {
                                cout<<"链表非满"<<endl;
                            }
                                break;
                                case 13:
                                susu.Sort();
                                break;
                                case 14:
                                    cout<<"当前链表的值为"<<endl;
                                    susu.output();
                                    break; }
    
         

                                     
    return 0;
}
 

小司不爱睡觉
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++模版类实现单链表
程序猿老樊的博客
05-05 995
单链表是一种基本的数据结构，它由一系列节点组成，每个节点都包含存储数据的值和一个指向列表中下一个节点的指针。如果当前节点是列表的最后一个节点，则该指针为null。单链表的实现原理；类的设计、封装；设计抽象类list并让单链表继承自list，是为了和顺序表、双链表配合，利用（纯）虚函数实现多态。通过使用C++模板，我们创建了一个灵活且类型无关的单链表数据结构。这样的实现使得单链表能够适应不同类型的数据存储需求，极大地增强了代码的复用性和扩展性。
单链表的类模板
11-14
单链表的基础类定义，方便引用
单向链表 ---- C++使用类模板实现
Zhoujy1996的博客
06-17 4579
单向链表 —- C++使用类模板实现 关于类模板的一些知识 与函数模板不同之处是，编译器不能为类模板推断模板参数类型。 当编译器从我们的 Demo 模板实例化出一个类时，它会重写 Demo 模板，将模板参数T的每个实例替换为给定的模板参数。 一个类模板的每个实例化都形成一个独立的类 类模板的成员函数 - 我们既可以在类模板内部，也可以在类模板外部为其定义成员函数，且定义在类...
问题 A: DS单链表--类实现
elapse_的博客
03-16 931
问题 A: DS单链表–类实现 时间限制: 1 Sec 内存限制: 128 MB 题目描述 用C++语言和类实现单链表，含头结点 属性包括：data数据域、next指针域 操作包括：插入、删除、查找 注意：单链表不是数组，所以位置从1开始对应首结点，头结点不放数据 类定义参考 输入 n 第1行先输入n表示有n个数据，接着输入n个数据 第2行输入要插入的位置和新数据 第3行输入要插入的位置和新数据 第4行输入要删除的位置 第5行输入要删除的位置 第6行输入要查找的位置 第7行输入要查找的位置 输出 n 数
826. 单链表 +数组模拟单链表
qq_45638271的博客
08-13 199
实现一个单链表，链表初始为空，支持三种操作： 向链表头插入一个数； 删除第 k 个插入的数后面的数； 在第 k 个插入的数后插入一个数。 现在要对该链表进行 M 次操作，进行完所有操作后，从头到尾输出整个链表。 注意:题目中第 k 个插入的数并不是指当前链表的第 k 个数。例如操作过程中一共插入了 n 个数，则按照插入的时间顺序，这 n 个数依次为：第 1 个插入的数，第 2 个插入的数，…第 n 个插入的数。 输入格式 第一行包含整数 M，表示操作次数。 接下来 M 行，每行包含一个操作命令，操作命令可能
单链表的C++实现（采用模板类）
weixin_34179968的博客
07-06 803
采用模板类实现的好处是，不用拘泥于特定的数据类型。就像活字印刷术，制定好模板，就可以批量印刷，比手抄要强多少倍！ 此处不具体介绍泛型编程，还是着重叙述链表的定义和相关操作。     链表结构定义 定义单链表的结构可以有4方式。如代码所示。 本文采用的是第4种结构类型 /*********************************************************...
C++用类模板的方法设计简单的单向链表
最新发布
wenchm的博客
06-02 387
1、class_CList利用类模板对链表类CList进行了修改，实际上是在原来链表的基础上将链表中出现的CNode类型的地方替换为模板参数Type2、同理。再定义一个节点类CNet和节点类CNode。并以实例演示模板类CList是如何适应不同的节点类型的。
C++使用模板实现单链表（类外实现）
08-26
本文主要介绍了使用C++模板实现单链表的相关知识点，包括类外实现的单链表的设计、实现和应用。 首先，单链表是一种常用的数据结构，它是一种链式结构，通过指针将各个节点连接起来，每个节点都包含一个指针，指向...
C++使用模板实现单链表
12-31
本文实例为大家分享了用模板实现单链表，供大家参考，具体内容如下 话不多说 直接上代码 #include using namespace std; template class CLink; template class Node { friend class CLink; public: /* 构造...
单链表的C++模板实现
08-09
用C++模板方式实现自定义单链表，交流学习用
c++实现单链表(类模板实现,详细注释)
终成大师的博客
02-19 6692
我是计算机专业的一位本科生,现在是大一,希望我的代码对你有所帮助，欢迎斧正 单链表的结点 以下图片均取自《数据结构c++》第二版 尾插法 即为将每次新申请的结点插到终端结点的后面 头插法 即为将每个新申请的结点都插入到头结点的后面 结点插入时的情况 运行结果： 代码实现： #include<iostream> using namespace std; template&lt...
类模板之单链表
Keep It Simple, Stupid
08-12 1024
// Chain.h #ifndef _CHAIN_H_ #define _CHAIN_H_ template class ChainNode { public: T data; ChainNode *link; }; template class Chain { public: Chain(); ~Chain(); bool IsEmpty() const; int Len
类模板实现单链表
Tangbincheng的博客
03-22 1743
特别注意：编写函数前必须先进行模板的声明#include&lt;iostream&gt; using namespace std; template&lt;typename type&gt; class list;//声明list类 template&lt;typename type&gt; class listnode { friend class list&lt;type&gt;;//访问私...
单链表模板类c++实现
SWC0619的博客
03-23 3714
c++实现单链表
C++单链表的模板类实现（含文件输入输出）
m0_53917001的博客
10-05 1739
#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++实现（模板技术、数据结构）
m0_73678116的博客
03-11 464
由于类模板成员函数创建时机实在程序运行阶段，所以在代码的分文件编写过程中需要特殊处理，一种解决方法为在主函数cpp文件直接包含类模板的实现文件（.cpp）文件；第二种是将类模板的声明和实现全都放在头文件（.h）里，头文件后缀改成.hpp文件。：standard template library（C++标准模板库）：英语中常理解为推，这里我们理解成压入，就是栈中压栈的那个压。：直译为弹出，栈中为出栈的意思，在链表中代表摘链。在代码中通常简写成seq。：队尾，代码中常简写为r。
单链表 C++ 实现 （使用类模板）
TanWaiwai_yy的博客
03-04 2062
写在前面之前学《数据结构》课程之前，老师叫我先熟悉熟悉单链表的，但在网上找了很多，都感觉不是很好（也有可能是看的不怎么仔细）也是看的迷迷糊糊的。今天好好学了之后，想给大家分享分享。首先是抽象基类的建立和预编译命令#pragma once #include &lt;iostream&gt; using namespace std; template &lt;class elemType&gt; ...
单向链表C++模板实现
weixin_70343234的博客
02-03 439
单向链表C++实现
单链表类型模板
wangxiaoxiao0108的博客
05-07 1526
单链表类型模板 单链表类模板，本例作为一个头文件。单链表的结点采用类，与结点有关的基本操作都作为结点类的成员函数。对链表整体的操作则作为链表类的成员函数，包括清空链表、查找数据、计算单链表长度、打印链表数据、向前生成链表、向后生成链表、按升序生成链表等等。 "Ex7_5.h" #include<iostream> using namespace std; //首先看结点组织，采用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值