C++单向链表实例

最新推荐文章于 2022-04-14 10:49:55 发布
最新推荐文章于 2022-04-14 10:49:55 发布
阅读量510 收藏 1
点赞数
分类专栏： C/C++

给个新建模板类的例子MyNodeList <pixeldata> nd=new MyNodeList<pixeldata>();//链表初始化 其中pixeldata是自己定义的一个结构体


//Node.h

template <class T>
class Node
{
private:
          Node<T>* next;
          T data;
public:
           Node();
           Node(const T& item,Node<T>* ptrnext=NULL);
           ~Node();
           void SetData(T &item);          //设置节点的数据域
           T GetData() const;                     //取节点的数据域 
          void InsertAfter(Node<T> *p);   //在节点后插入一个节点P
          Node<T>* DeleteAfter();        //删除节点邻接的下一个节点
          Node<T>* NextNode() const;      //取节点邻接的下一个节点
};//---------------


template<class T>
Node<T>::Node():next(NULL){}    //空的构造函数
template<class T>
Node<T>::Node(const T &item,Node<T>* ptrnext)
{
        data=item;
        next=ptrnext;
}//-----------------------------------------------
template<class T>
Node<T>::~Node()         //析构函数
{
       delete[] next;
}//-----------------------------------------------
template<class T>
void Node<T>:: SetData(T &item)   //设置节点的数据域 
{ 
        data=item;
}//-----------------------------------------------
template<class T>
T Node<T>::GetData()const     //取节点的数据域
{
        return data;
}//----------------------------------------------- 
template<class T>
void Node<T>::InsertAfter(Node<T>*p)   //在节点后插入一个节点P
{
        p->next=next;
        next=p;
}//-----------------------------------------------
template<class T>
Node<T>* Node<T>::DeleteAfter()     //删除节点邻接的下一个节点
{
        if(next==NULL) 
                 return NULL;
       Node<T>* tempptr=next;
        next=tempptr->next;
        return tempptr;
}//-----------------------------------------------
template<class T>
Node<T>* Node<T>::NextNode()const   //取节点邻接的下一个节点
{
         return next;
}//-------------------------------------------------------------------





//NodeList.h

#include "stdafx.h"
template <class T>
class NodeList
{
private:
      Node<T> *front,*rear;    //表头和表尾指针
      Node<T> *currptr;       //指向当前节点的指针
      Node<T> *GetNode(const T &item,Node<T>*ptrNext=NULL); //构造一个节点
public:
      NodeList();
      NodeList(const NodeList<T>& L);      //拷贝构造函数
      ~NodeList();
      void Reset();          //复位，将currptr重新指向表头
      void InsertFront(const T& item);     //表头插入节点
      void InsertRear(const T& item);   //表尾插入节点
      void InsertAfter(const T& item);    //在当前节点（currptr所指节点）处插入节点
      int Find(const T &item); //在链表中查找item，若在链表中返回1并把currptr指向item第一次出现的     节点；若没有返回0
      void LSort();    //按数据域大小从小到大排序
      void Reverse(); //倒置链表
      int IsEmpty();   //链表是否为空
      int IsEndOfNodeList(); //当前指针currptr是否到达表尾
       void Next();   //当前指针currptr指向下一个节点，并返回该节点
      T Data();         //取当前节点的数据域
      Node<T>* DeleteAt();           //删除当前节点 
      void PrintNodeList();       //打印链表
};//-----------------------------------------------

template<class T>
NodeList<T>::NodeList():front(NULL),rear(NULL),currptr(NULL){}
//-----------------------------------------------
template<class T>
NodeList<T>::NodeList(const NodeList<T>& L)    //拷贝构造函数
{
      L.Reset();
      while(!L.IsEndOfNodeList())
      {
           InsertRear(L.Data());
            L.Next();
      }
      InsertRear(L.Data());
}//-----------------------------------------------
template<class T>
NodeList<T>::~NodeList()
{
     delete[] front;
}//-----------------------------------------------
template<class T>
Node<T>* NodeList<T>::GetNode(const T &item,Node<T>*ptrNext) //构造一个节点
{
     Node<T>* newNode;
     newNode=new Node<T>(item,ptrNext);
     if(newNode==NULL)
     {
          cerr<<"Memory allocation failure!";
          exit(1);
     }
     return newNode;
}//-----------------------------------------------
template<class T>
void NodeList<T>::Reset()         //复位，将currptr重新指向表头
{
       currptr=front;
}//-----------------------------------------------
template<class T>
void NodeList<T>::InsertFront(const T& item)   //表头插入节点
{
      if(front==NULL)        //如果表为空，插入一个节点后，表头和表尾指针都要指向插入节点
      {
           front=rear=GetNode(item,front);
      }
      else
      {
           front=GetNode(item,front);
      }
}//-----------------------------------------------
template<class T>
void NodeList<T>::InsertRear(const T& item)    //表尾插入
{
      if(front==NULL)              //如果表为空，插入一个节点后，表头和表尾指针都要指向插入节点
      {
           front=rear=GetNode(item,front);
      }
      else
      {
           rear->InsertAfter(GetNode(item)); //表不为空时，在表尾插入节点，并将rear重新指向新的表尾
           rear=rear->NextNode();
      }
}//-----------------------------------------------
template<class T>
void NodeList<T>::InsertAfter(const T& item)   //在当前节点后插入节点
{
      if(currptr!=NULL)        //若表不为空，则currptr有值，可以插入
      {
          if(rear==currptr)
           {
                 InsertRear(item);
           }
           else
           {
                 currptr->InsertAfter(GetNode(item));
           }
      }
      else                     //若表为空，则currptr指向空，插入失败
      {
           cerr<<"currptr is null!!";
      }
}//-----------------------------------------------
template<class T>
int NodeList<T>::Find(const T& item)     //在链表中查找item，若在链表中返回1并把currptr指向item第一次出现的节点；若没有返回0
{
     Reset();
     while(currptr!=NULL&&Data()!=item)
     {
          currptr=currptr->NextNode();
     }
     if(currptr==NULL)    
           return 0;
     return 1;
}//-----------------------------------------------
template<class T>
void NodeList<T>::LSort()    //按数据域大小从小到大排序，链表若不会空，每次取链表中最大的节点放入临时链表中，并从原来链表中删除
{
      if(front==NULL)      //直到原来链表为空，排序完成
      {
          cerr<<"NodeList is empty!";
      }
      else
      {
          Node<T> *lptr=new Node<T>(); 
          Node<T> *rptr;        //记住排好序后的表尾,即链表中最大的节点
          Node<T> *tempptr;
          int flag=0;         //标记排好序后的表尾
          while(!IsEmpty())
          { 
               tempptr=front;
               Reset();
               while(currptr!=NULL) //每次循环都依次取链表中一个节点与tempptr比较，并将大的放入tempptr
               {
                     if(tempptr->GetData()<Data())
                              tempptr=currptr;
                     currptr=currptr->NextNode();   
               }
               if(flag==0) 
                   rptr=tempptr;     //记住排好序后的表尾
               flag=1;          
               currptr=tempptr;        //让currptr指向链表中最大的节点,及当前节点就是最大节点
               lptr->InsertAfter(DeleteAt()); //将最大的节点从原来链表中删除，并放入临时链表中
          }
          front=lptr->NextNode();   //将排好序的链表复制给要求排序的链表 
          rear=rptr;     //将排好序的表尾赋值给rear
      }
}//-----------------------------------------------
template<class T>
void NodeList<T>::Reverse()              //倒置链表，从表头删除并插入表尾
{
       if(front==NULL)
       {
           cerr<<"NodeList is empty!";
       }
       else
       {
           Node<T>* fptr;
           fptr=front;                 //记住开始的表头节点，以便赋值给倒置后的表尾
           while(front!=rear)
           {
                Reset();
                rear->InsertAfter(DeleteAt());    //表头删除插入表尾
           }
           rear=fptr;                //原来的表头节点赋值给倒置后的表尾
       }
}//-----------------------------------------------
template<class T>
int NodeList<T>::IsEmpty()
{
       return front==NULL;
}
template<class T>
T NodeList<T>::Data()       //取当前节点的数据域
{
      return(currptr->GetData());
}//-----------------------------------------------
template<class T>
int NodeList<T>::IsEndOfNodeList()
{
     return currptr==rear;
}//-----------------------------------------------
template<class T>
void NodeList<T>::Next()
{ 
    currptr=currptr->NextNode();
}//-----------------------------------------------
template<class T>
Node<T>* NodeList<T>::DeleteAt()    //删除当前节点
{
      if(currptr==front)     
      {
          if(front==rear)    //若链表中只有一个节点，表头表尾指针都要指向空
                 front=rear=NULL;
          else
                front=currptr->NextNode(); //若当前节点就是表头，删除后，表头指针顺序后延
      }
      else
      {   
            Node<T>* tempptr=front;    
            while(tempptr->NextNode()!=currptr)   //若当前节点不是表头，找到当前节点的前一个节点，通过Node<T>中定义的DeleteAfter()
            {                                      //删除当前节点
                tempptr=tempptr->NextNode();
            }
            tempptr->DeleteAfter();
       }
       return currptr;
}//-----------------------------------------------
template<class T>
void NodeList<T>::PrintNodeList()    //打印链表，每打印十个，换行
{
       Node<T> *tempptr=front;
       int count=1;
       while(tempptr!=NULL)
       {
            cout<<tempptr->GetData()<<" ";
            if((count++)%10==0) 
            cout<<endl;
            tempptr=tempptr->NextNode();
       }
       cout<<endl;
}//-----------------------------------------------


twt5ps
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++的单链表例子
Milky_Yankee的博客
05-05 484
C++的单链表例子 单链表的创建有两种方式：头插法和尾插法 // 头插法 ——将每个新节点都插入到链表的头结点first的后面，相当于倒序 s = new Node; s->data = a[i]; ① s->next = first->next; ② first->next = s; // 尾插法 ——将每个新节点都插入到终端结点的后面 (r=first) s = new Node; s->data = a[i]; r->next = s; r = s; r->
C++ 单向链表 —— 初始化、插入、返回第一个节点、删除、查找、长度、打印、反转(逆序)
辛旭东小小工作室
03-15 3012
单向链表的概念： 如果“一个节点”将指向“另一个节点的指针”作为数据成员，那么多个这样的节点可以连起来，只用一个变量就能够访问整个节点序列，我们称之为链表。如果序列中的节点只包含指向后继节点的链接，该链表就称之为单向链表。 01 声明： #ifndef LINKLIST_H #define LINKLIST_H #include <iostream> using name...
一个c++链表完整例子
09-29
一个c++链表完整例子，包括了有关于链表的所有基本操作的实现，简单易懂！
单向链表的典型例子
03-28
很好的一个说明了单向链表的操作方法 创建
c++单链表样例
Child_heart的博客
04-09 705
#include "stdafx.h" #include&lt;iostream&gt; using namespace std; template&lt;class T&gt; struct Node //定义结构体 { T data; Node&lt;T&gt; *next; }; template&lt;class T&gt;//定义模板类 class Linklist { public...
【C++】单向链表
taoxing
07-09 1600
一.基本介绍 单向链表是链表中的一种，它链接的方向是单向的，而且对链表的访问要从头部开始，依次往下读取。 一个单向链表的节点被分为两部分，第一部分保存该节点的相关信息，第二个节点存储下一个节点的地址。 链表中节点的地址是不连续的。 实现思路： （1）我们需要实现两个类，一个类为节点类，存储相关信息与下一个节点的地址；一个为链表类，头节点作为其变量。 （2）在这里我们以学生信息作为节点进行实现，基本信息包括学号、姓名（写的简洁一下）。 （3）单链表包括节点的增删查改以及链表的打印。 单链
C++中链表操作实例分析
01-20
链表概述 　链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。... 链表的各类操作包括：学习单向链表的创建、删除、 插入（无序、有序）、输出、 排序（选择、插入、冒泡）、反
单向链表类模板（全）C++
01-22
在C++编程中，单向链表是一种基本的数据结构，用于存储动态集合。单向链表的特点是每个节点包含一个数据元素和一个指向下一个节点的指针，最后一个节点的指针为空。本压缩包文件提供了实现单向链表类模板的完整代码...
用C++实现单向循环链表的解决方法
09-05
在C++中实现单向循环链表涉及创建一个表示节点的结构体，定义链表类以及实现相关操作的方法。 首先，我们定义了一个模板结构体`NODE<T>`，用于表示链表中的节点。这个结构体包含两个成员：一个类型为`T`的数据域`...
单向链表模板
06-02
在C++编程中，单向链表是一种常用的数据结构，用于存储和操作一系列有序或无序的数据元素。链表与数组不同，它不连续存储数据，而是通过节点间的指针连接，每个节点包含数据和指向下一个节点的指针。在这个场景中，...
实例讲解：单向链表实现（2）
08-06
NULL 博文链接：https://chaoyi.iteye.com/blog/2078088
实现一个模板类的链表（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++类模板，实现的单链表基本操作
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++ 实现简单的单向链表
weixin_42333471的博客
03-06 741
为了练习一下对链表的理解，尝试手动造轮子，实现单向链表的右添加，左添加和删除的功能。 头文件 #pragma once #include&lt;iostream&gt; using namespace std; struct Node//节点 { int value; Node* next; Node(int a = 0, Node* n = NULL) :value(a), next(n)...
C++实现链表的例子
qq_20608169的博客
06-19 382
C语言实现的链表 #ifndef LINKLIST_H #define LINKLIST_H #include<stdlib.h> #include<stdio.h> //链表结点 typedef struct LINKNODE{ void* data; //指向任何类型的数据 struct LINKNODE* next; }LinkNode; //链表结构体 typedef struct LINKLIST{ LinkNode* head; int size; /
C++数据结构---单向链表的实现
Rookie_Ws的博客
04-14 649
链表.h #pragma once #include<iostream> using namespace std; class Linknode { public: friend class Mylist; private: Linknode(int num); //构造函数 int num; //存放数值 Linknode* next; //存放下一结点的地址 }; class Mylist { public: Mylist() { first = NULL;
单链表程序范例(C++)
weixin_30540691的博客
04-20 313
1 #include<iostream> 2 #include<stdlib.h> 3 using namespace std; 4 typedef struct tagNote 5 { 6 int nNumber; 7 struct tagNote* pNext; 8 }Note; 9 10 b...
c++链表实例与链表基本知识
星空中的一颗星
07-13 1753
我们知道，数组是事先定义好的数组类型与长度 自动为其分配的一连续的存储单元相同数组的位置和距咯是固定的因此可以对数组元素进行随机访问。但若对数组元素进行插入和删除操做，则会引起大量的数据移动，从而使数据处理变得非常复杂，低效。 为了解决这个问题，一种称为“链表”的数据结构得到了广泛的应用。 1. 链表概述 链表是一种数据结构，他的特点是用一组任意的存储单元（可以是连续的，也可以是不连
C++单向链表模板类
y0205yang的博客
09-13 386
#include <iostream> #include <stdio.h> using namespace std; template<typename T> class Node{ public: T data; Node<T>* next; Node<T>* last; Node(T d=0) {data=d;cout<<"Node Constructor run"<<endl;} .
C++自定义单向链表操作详解与实例
本文主要介绍了C++语言中单向链表的基本操作，这是数据结构和算法领域的重要知识点。单向链表是一种线性数据结构，每个节点包含数据和指向下一个节点的指针，允许高效地添加、删除和遍历元素。 1. 创建单向链表：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值