c++ 数据结构 链表类（详解）

已于 2022-10-11 22:42:40 修改
阅读量1.6k 收藏 18
点赞数 10
分类专栏： 数据结构 文章标签： 链表 数据结构 c++
于 2022-09-28 17:35:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59629651/article/details/127093413
版权

包含链表类的一些基本操作。

大二数据结构课后题，之后会慢慢更新更多操作。

还有许多方法写法不够简洁完善，会慢慢更新

完整代码在最后

首先是类的设计：

typedef int ElementType;

class LinkList

{

private:

 class Node

 {

    public:

    ElementType data;

    Node * next;

    Node():next(0) {}//默认构造函数

    Node(ElementType dataValue):data(dataValue), next(0){}//显值构造函数

 };

public:

 typedef Node * NodePointer;

 LinkList(){mySize = 0;first = 0;}   //构造函数

 LinkList(const LinkList & origList);//复制构造函数

 ~LinkList();  //析构函数

 //void release();

 const LinkList & operator=(const LinkList & rightSide); //赋值运算符重载

 bool empty();  //链表判空

 void insert(ElementType dataVal, int index); //在链表指定位置插入节点

 void erase(int index);  //删除链表中指定位置的节点

 NodePointer search(ElementType dataVal); //查找链表中指定值的节点

 void display(ostream & out) const;//输出链表节点值

 void input(istream & in,int n);

 int nodeCount();   //计算节点个数

 void reverse();      //链表反转，即尾结点变为链表第一个节点

 bool ascendingOrder();  //判断链表是否为升序排列

 void ListMerge(LinkList & templist);//链表B合并到链表A末尾

 void MergeList(LinkList & listA,LinkList & listB);//链表A和链表B合并到链表C上

 ElementType get(NodePointer temp); 

private:

 NodePointer first; //指向第一个节点的指针

 int mySize; //节点的数目

};

方法的实现：

1.拷贝构造函数：

LinkList::LinkList(const LinkList & origList){//拷贝函数
   mySize = origList.mySize;
   first = 0;
   if(mySize == 0)return;
   NodePointer origPtr,lastPtr;
   first = new Node(origList.first->data);
   lastPtr = first;
   origPtr = origList.first->next;
   while(origPtr != 0){
      lastPtr->next = new Node(origPtr->data);
      origPtr = origPtr->next;
      lastPtr = lastPtr->next;
   }

}

LinkList::~LinkList(){//析构函数
   NodePointer prev = first,ptr;
   while(prev != 0){
      ptr = prev->next;
      delete prev;
      prev = ptr;
   }
}

2.empty函数：

bool LinkList::empty(){//判断是否为空
   if(!mySize)return true;
   return false;
}

3.insert插入节点

void LinkList::insert(ElementType dataVal, int index){//在index位置插入dataVal
   if(index < 0 || index > mySize){
      cerr << "illegal to insert--" << index << endl;
      return; 
   }
   mySize++;
   NodePointer newPtr = new Node(dataVal),prePtr = first;
   if(index == 0){//插入到第一个位置
      newPtr->next = first;
      first = newPtr;
   }
   else{//若列表不为空
      for(int i = 0;i < index-1;i++){//不断移动插入，移动index-1次，即插入到所需位置
         prePtr = prePtr->next;
      }
      newPtr->next = prePtr->next; 
      prePtr->next = newPtr;
   }
}

4.erase 删除节点

void LinkList::erase(int index){//删除第index个节点
   if(index < 0 || index >= mySize || empty()){
      cerr << "illegal to erase--" << index << endl;
      return; 
   }
   mySize--;
   NodePointer prePtr = first;
   if(mySize==1){//若只有一个节点
      first = 0;
   }
   else{
      if(index == 0){
         first = prePtr->next;
         delete prePtr;
         return;
      }
      for(int i = 1;i < index-1;i++)//删除index节点，只需移动到index-1位置
        prePtr = prePtr->next;
      prePtr->next = prePtr->next->next;//将prePtr的next连接至下下个节点
   }
}

5.查找指定数据的指定节点（注意最前面NodePointer要声明是Linklist里的）

LinkList::NodePointer LinkList::search(ElementType dataVal){//查找链表中指定值的节点
   if(empty()){
      cerr << "illegal to search--" << dataVal << endl;
   }
   NodePointer prePtr = first;
   while(prePtr->data != dataVal)
      prePtr = prePtr->next;
   if(prePtr==0)
      cerr << "illegal to search--" << dataVal << endl;
   else
      return prePtr;
}

6.display输出链表节点值，与输出重载相结合使用

void LinkList::display(ostream & out) const{//输出链表节点值
   NodePointer prePtr = first;
   while(prePtr != 0){
      out<<prePtr->data<<" ";
      prePtr = prePtr->next;
   }
}

7.input输入流函数，与提取重载相结合使用

void LinkList::input(istream & in,int n){//输入链表节点值
   int mysize1 = 0;
   for(int i = 0;i < n;i++){
      cout<<"请输入第"<<i+1<<"个节点的数据:";
      ElementType x;
      in>>x;
      insert(x,mysize1);
   }
}

8.nodeCount计算共有几个节点

int LinkList::nodeCount(){   //计算节点个数
   return mySize;
}

9.reverse反转函数

void LinkList::reverse(){//链表反转，即尾结点变为链表第一个节点
   NodePointer old_head = first,new_head=0,temp;
   while(old_head){
      temp = old_head->next;
      old_head->next = new_head;
      new_head =old_head;
      old_head = temp;
   }
   first = new_head;
}

10.判断是否递增

bool LinkList::ascendingOrder(){//判断链表是否为升序排列
   NodePointer prePtr = first;
   while(prePtr->next != 0){
      if(prePtr->data > prePtr->next->data)return false;
      prePtr = prePtr->next;
   }
   return true;
}

11.把B合并进A，且B不变，两个指针同时递增，B中每个节点拷贝一个，防止B发生改变

void LinkList::ListMerge(LinkList & templist){//链表B合并到链表A末尾
   NodePointer prePtr = first;
   while(prePtr->next != 0)
      prePtr = prePtr->next;
   NodePointer prePtrB = templist.first;
   while(prePtrB != 0){
      this->mySize++;
      prePtr->next = new Node(prePtrB->data);
      prePtrB = prePtrB->next;
      prePtr = prePtr->next;
   }
}

12.把A，B合并，再接到C（本身）

void LinkList::MergeList(LinkList & listA,LinkList & listB){//链表A和链表B合并到链表C上
   listA.ListMerge(listB);
   this->ListMerge(listA);
}

13.get函数

ElementType LinkList::get(NodePointer temp){
   return temp->data;
}

14.插入运算符重载

ostream & operator<<(ostream & out, const LinkList &List){ //插入运算符重载（可选做）
   List.display(out);
   return out;
}

15.提取运算符重载

istream & operator>>(istream & in, LinkList &List){//提取运算符重载（可选做）
   cout<<"请输入链表节点的个数:";
   int N;
   cin >> N;
   List.input(in,N);
   return in;
}

16.赋值重载符：

LinkList const &LinkList::operator=(const LinkList &rightSide) //赋值运算符重载
{
    mySize = rightSide.mySize;
    first=0;
    NodePointer origPtr,lastPtr;
    first = new Node(rightSide.first->data);
    lastPtr = first;
    origPtr = rightSide.first->next;
    while (origPtr != 0)
    {
        lastPtr->next = new Node(origPtr->data);
        origPtr= origPtr->next;
        lastPtr = lastPtr->next;
    }
    return *this;
}

完整code（含测试）：

#include<iostream>
using namespace std;
typedef int ElementType;

class LinkList

{

private:

 class Node

 {

    public:

    ElementType data;

    Node * next;

    Node():next(0) {}//默认构造函数

    Node(ElementType dataValue):data(dataValue), next(0){}//显值构造函数

 };

public:

 typedef Node * NodePointer;

 LinkList(){mySize = 0;first = 0;}   //构造函数

 LinkList(const LinkList & origList);//复制构造函数

 ~LinkList();  //析构函数

 //void release();

 const LinkList & operator=(const LinkList & rightSide); //赋值运算符重载

 bool empty();  //链表判空

 void insert(ElementType dataVal, int index); //在链表指定位置插入节点

 void erase(int index);  //删除链表中指定位置的节点

 NodePointer search(ElementType dataVal); //查找链表中指定值的节点

 void display(ostream & out) const;//输出链表节点值

 void input(istream & in,int n);

 int nodeCount();   //计算节点个数

 void reverse();      //链表反转，即尾结点变为链表第一个节点

 bool ascendingOrder();  //判断链表是否为升序排列

 void ListMerge(LinkList & templist);//链表B合并到链表A末尾

 void MergeList(LinkList & listA,LinkList & listB);//链表A和链表B合并到链表C上

 ElementType get(NodePointer temp); 

private:

 NodePointer first; //指向第一个节点的指针

 int mySize; //节点的数目

};

LinkList::LinkList(const LinkList & origList){//拷贝函数
   mySize = origList.mySize;
   first = 0;
   if(mySize == 0)return;
   NodePointer origPtr,lastPtr;
   first = new Node(origList.first->data);
   lastPtr = first;
   origPtr = origList.first->next;
   while(origPtr != 0){
      lastPtr->next = new Node(origPtr->data);
      origPtr = origPtr->next;
      lastPtr = lastPtr->next;
   }

}

LinkList::~LinkList(){//析构函数
   NodePointer prev = first,ptr;
   while(prev != 0){
      ptr = prev->next;
      delete prev;
      prev = ptr;
   }
}

bool LinkList::empty(){//判断是否为空
   if(!mySize)return true;
   return false;
}

LinkList const &LinkList::operator=(const LinkList &rightSide) //赋值运算符重载
{
    mySize = rightSide.mySize;
    first=0;
    NodePointer origPtr,lastPtr;
    first = new Node(rightSide.first->data);
    lastPtr = first;
    origPtr = rightSide.first->next;
    while (origPtr != 0)
    {
        lastPtr->next = new Node(origPtr->data);
        origPtr= origPtr->next;
        lastPtr = lastPtr->next;
    }
    return *this;
}
void LinkList::insert(ElementType dataVal, int index){//在index位置插入dataVal
   if(index < 0 || index > mySize){
      cerr << "illegal to insert--" << index << endl;
      return; 
   }
   mySize++;
   NodePointer newPtr = new Node(dataVal),prePtr = first;
   if(index == 0){//插入到第一个位置
      newPtr->next = first;
      first = newPtr;
   }
   else{//若列表不为空
      for(int i = 0;i < index-1;i++){//不断移动插入，移动index-1次，即插入到所需位置
         prePtr = prePtr->next;
      }
      newPtr->next = prePtr->next; 
      prePtr->next = newPtr;
   }
}

void LinkList::erase(int index){//删除第index个节点
   if(index < 0 || index >= mySize || empty()){
      cerr << "illegal to erase--" << index << endl;
      return; 
   }
   mySize--;
   NodePointer prePtr = first;
   if(mySize==1){//若只有一个节点
      first = 0;
   }
   else{
      if(index == 0){
         first = prePtr->next;
         delete prePtr;
         return;
      }
      for(int i = 1;i < index-1;i++)//删除index节点，只需移动到index-1位置
        prePtr = prePtr->next;
      prePtr->next = prePtr->next->next;//将prePtr的next连接至下下个节点
   }
}

LinkList::NodePointer LinkList::search(ElementType dataVal){//查找链表中指定值的节点
   if(empty()){
      cerr << "illegal to search--" << dataVal << endl;
   }
   NodePointer prePtr = first;
   while(prePtr->data != dataVal)
      prePtr = prePtr->next;
   if(prePtr==0)
      cerr << "illegal to search--" << dataVal << endl;
   else
      return prePtr;
}

void LinkList::display(ostream & out) const{//输出链表节点值
   NodePointer prePtr = first;
   while(prePtr != 0){
      out<<prePtr->data<<" ";
      prePtr = prePtr->next;
   }
}

void LinkList::input(istream & in,int n){//输入链表节点值
   int mysize1 = 0;
   for(int i = 0;i < n;i++){
      cout<<"请输入第"<<i+1<<"个节点的数据:";
      ElementType x;
      in>>x;
      insert(x,mysize1);
      mysize1++;
   }
}

int LinkList::nodeCount(){   //计算节点个数
   return mySize;
}

void LinkList::reverse(){//链表反转，即尾结点变为链表第一个节点
   NodePointer old_head = first,new_head=0,temp;
   while(old_head){
      temp = old_head->next;
      old_head->next = new_head;
      new_head =old_head;
      old_head = temp;
   }
   first = new_head;
}

bool LinkList::ascendingOrder(){//判断链表是否为升序排列
   NodePointer prePtr = first;
   while(prePtr->next != 0){
      if(prePtr->data > prePtr->next->data)return false;
      prePtr = prePtr->next;
   }
   return true;
}

void LinkList::ListMerge(LinkList & templist){//链表B合并到链表A末尾
   NodePointer prePtr = first;
   while(prePtr->next != 0)
      prePtr = prePtr->next;
   NodePointer prePtrB = templist.first;
   while(prePtrB != 0){
      this->mySize++;
      prePtr->next = new Node(prePtrB->data);
      prePtrB = prePtrB->next;
      prePtr = prePtr->next;
   }
}

void LinkList::MergeList(LinkList & listA,LinkList & listB){//链表A和链表B合并到链表C上
   listA.ListMerge(listB);
   this->ListMerge(listA);
}

ElementType LinkList::get(NodePointer temp){
   return temp->data;
}
ostream & operator<<(ostream & out, const LinkList &List){ //插入运算符重载（可选做）
   List.display(out);
   return out;
}

istream & operator>>(istream & in, LinkList &List){//提取运算符重载（可选做）
   cout<<"请输入链表节点的个数:";
   int N;
   cin >> N;
   List.input(in,N);
   return in;
}

int main(){
   LinkList l;
   LinkList l2;
   cin>>l;
   LinkList l1(l);
   l2 = l;
   cout<<l2<<endl;
   cout<<l<<endl;
   l.reverse();
   cout<<l<<endl;
   cout<<l.nodeCount()<<endl;
   l.ListMerge(l1);
   cout<<l<<endl;
   cout<<l.nodeCount()<<endl;
   l.erase(4);
   cout<<l<<endl;
   l.insert(10,7);
   cout<<l<<endl;
   if(l.ascendingOrder())cout<<"递增"<<endl;
   else cout<<"不递增"<<endl;
   if(l.empty())cout<<"空链表"<<endl;
   else cout<<"非空链表"<<endl;
   return 0;
}

CorzanX77
关注
  • 10
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
详解C++ 拷贝构造函数
01-19
拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数通常用于： 通过使用另一个同类型的对象来初始化新创建的对象。 复制对象把它作为参数传递给函数。 复制对象，并从函数返回这个对象。 如果在类中没有定义拷贝构造函数，编译器会自行定义一个。如果类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数。拷贝构造函数的最常见形式如下： classname (const classname &obj) { // 构造函数的主体 } 在这里，obj 是一个对象引用，该对象是用于初始化另一个对象的。 #include <io
C++ 链表
m0_62175410的博客
07-26 3万+
C++链表笔记
C++知识点总结(27)：链表
最新发布
joe_g12345的博客
03-30 987
/ 将(x的地址)放入(指针y)中。
[Python]数据结构--链表
Festinatione facit vastum
01-11 581
[Python]数据结构–链表 ‘Festinatione facit vastum’ 链表的概念 单链表的实现 循环单链表的实现 链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另
C++ 数据结构与算法（四）（链表）
chenyfan_blog
02-24 6657
链表 LeetCode 代码随想录
c++链表（详解版）
热门推荐
slandarer的博客
06-13 21万+
在自学C++的时候，看到好多人都在提链表，于是就自学了一下，看了很多别人的文章，加入了一些自己的理解，做了一下总结
C语言/C++实现链表的详细教程
qq_43884946的博客
06-14 1万+
链表是一种常用的数据结构，它由一系列节点组成，每个节点包含两部分内容：数据和指向下一个节点的指针,最后一个节点指向空。链表的节点可以动态添加和删除，因此可以方便地进行插入、删除等操作。链表有多种类型，包括单向链表、双向链表和循环链表等。
C++利用链表写一个简单的栈实例详解
01-01
自己写一个栈能让我们对栈这种数据结构更加熟悉。这个栈有一个不足之处就是里面存放的元素类型只能为int。 #include using namespace std; class Stack { private: struct Node { int data; Node *next; }; ...
Visual C++ 6.0编程实例详解.part1
09-25
11．2 链表类 11．3 CPont类 11．4 CRect类 11．5 CSize类 11．6 CString类 11. 7 CTirne类 11．8 CTimeSpan类 第12章 MFC 12．1 简介 12．2 分层 12．2．1 根类 12．2．2 MFC应用程序结构类 12．2．3 ...
Visual C++ 6.0编程实例详解.part2
09-25
11．2 链表类 11．3 CPont类 11．4 CRect类 11．5 CSize类 11．6 CString类 11. 7 CTirne类 11．8 CTimeSpan类 第12章 MFC 12．1 简介 12．2 分层 12．2．1 根类 12．2．2 MFC应用程序结构类 12．2．3 ...
C++语言描述(PDF合集)
07-13
第二部分 数据结构 第3章 数据描述 75 3.1 引言 75 3.2 线性表 76 3.3 公式化描述 77 3.3.1 基本概念 77 3.3.2 异常类NoMem 79 3.3.3 操作 79 3.3.4 评价 83 3.4 链表描述 86 3.4.1 类ChainNode 和Chain 86 3.4.2 ...
Absolute C++中文版(原书第2版)-完美的C++教程，文档中还包含英文版
09-11
第17章　链式数据结构 487 17.1　节点和链表 487 17.1.1　节点 487 17.1.2　链表 491 17.1.3　向链表头插入一个节点 492 17.1.4　向链表中插入或移除节点 495 17.1.5　搜索链表 498 17.2　链表的应用 504 17.3　迭代...
C++ 万字长文，链表详解
jinjiayang的博客
12-02 4126
C++链表详解（包括迭代器，链式存储等诸多干货）
数据结构：链表及其C++实现
forGemini的博客
05-26 1万+
前言 链表是一种非常非常基础的数据结构，本文首先讲解链表的基础知识，然后使用C++的模板实现了一个链表类，并简单实现了常见的插入、删除、查找等算法。 阅读本文需要对C/C++的指针具有一定的了解。 基础知识 链表是一种逻辑上连续，内存上分散的线性表数据结构，其基本单位为结点，每个结点分数据区和指针区，数据区用于存放数据，指针区则用于指向其他结点，通过指针每个结点就被串接成了一条“链子”。
c++数据结构——链表
qq_35686734的博客
06-13 2万+
1.链表基础知识： 链表分类：单链表、双链表、循环链表 链表的存储：散乱分布，通过指针域的指针链接在一起 链表的定义：此处给出单链表的c++定义 struct ListNode { int val; // 节点上存储的元素 ListNode *next; // 指向下一个节点的指针 ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数 }; 链表初始化及调用： ListNode* head = new ListNode(5);
利用C++超详细解释数据结构中的链表
Mr.林先生的博客
03-24 2613
链表是一种线性数据结构，它由一系列节点组成，每个节点包含两个部分：数据部分和指针部分。数据部分用来存储节点的数据，指针部分用来指向下一个节点。int val;// 数据部分// 指针部分，指向下一个节点ListNode(int x) : val(x), next(nullptr) {} // 构造函数其中，val表示节点的数据，next指向下一个节点的指针。构造函数用来初始化节点的数据和指针部分。
C++基础语法：链表
baiyechangjiu的博客
08-19 7447
链表是物理存储单元上非连续的，非顺序的存储结构，链表是由一个个结点，通过指针来联系起来的，其中每个结点包含数据和指针： 或者我们采用另一张更加明显的图： 因为在C++语言中，当我们生成一个数组的时候，就要声明数组的长度，如此计算机便会在内存上开辟一个连续的不间断的内存空间来存储数据，因为存在着这样的一种可能，也就是数组所使用的内存空间之后的内存空间已经被使用，所以C++中一旦数组的大小明确了，就不能够再改变了。而且因为数组是存储一系列的同一类型的变量的集合，所以构成数组的每一个元素占用的内.
C++链表类
qq_44205540的博客
11-25 849
C++链表类
C++数据结构之链表（详解）
suren_jun的博客
10-18 3628
链表的定义一种线性表数据结构。它使用一组任意的存储单元，来存储一组具有相同类型的地址，但是链表一般是内嵌到数据结构中，而数据结构的类型可以是不同的。
C++数据结构双链表的反转
08-23
这段代码首先定义了一个 `Node` 结构体来表示双链表的节点，其中包括一个数据域 `data`、一个指向前驱节点的指针 `prev`，以及一个指向后继节点的指针 `next`。 在 `reverse` 函数中，我们使用一个临时变量 `temp` ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值