数据结构C++ 实现单链表

最新推荐文章于 2024-08-02 23:01:29 发布
最新推荐文章于 2024-08-02 23:01:29 发布
阅读量893 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35496811/article/details/123751369
版权

link.h

#ifndef LINK_H
#define LINK_H
#pragma once
#include <iostream>
#define OK 1
#define fail 0
using namespace std;

template <class T>
class Node
{
public:
  Node<T> *next;
  T *data;
};

template <class T>
class Link
{
private:
  Node<T> *head;
  int length;

public:
  // 构造函数，初始化链表
  Link();
  // 拷贝构造
  Link(const Link<T> &ln);
  // 析构
  ~Link();
  // 指定位置添加节点
  int link_insert(int pos, T *value);
  // 遍历链表
  void link_foreach(void(print)(T *));
  // 删除尾结点
  T *link_pop();
  // 添加尾节点
  int link_push(T *value);
  // 删除头结点
  T *link_shift();
  // 添加头结点
  int link_unshift(T *value);
  // 输出指定位置节点
  T * link_index(int index);
  // 查找节点
  T * link_find(bool(print)(T *));
  // 翻转链表
  int link_reverse();
  // 获取链表长度
  int link_length();
  // 清空链表
  int link_clear();
  // 销毁链表
  int link_destory();
  // 连接链表
  Link<T>& operator+(const Link<T> &plink);
};

#endif //TEST1_LIST_H

link.cpp

#include "link.h"

// 初始化链表
template<typename T>
Link<T>::Link(){
  this->head=new Node<T>;
  this->head->next=NULL;
  this->head->data=NULL;
  this->length=0;
}

// 拷贝构造
template<typename T>
Link<T>::Link(const Link<T> &ln){
  this->length=ln.length;
  this->head=new Node<T>;
  this->head->next=NULL;
  Node<T> *p=this->head;
  Node<T> *move=ln.head->next;
  for(int i=0;i<this->length;++i){
    Node<T> *newNode=new Node<T>;
    newNode->data=move->data;
    newNode->next=NULL;
    p->next=newNode;
    p=newNode;
    move=move->next;
  }
}

// 析构
template<typename T>
Link<T>::~Link(){
  this->link_destory();
}

// 指定位置添加节点
template<typename T>
int Link<T>::link_insert(int pos,T *value){
  if(!value){
    return fail;
  }
  if(pos<0||pos>this->length){
    pos=this->length;
  }
  Node<T> *pCur=this->head;
  for(int i=0;i<pos;++i){
    pCur=pCur->next;
  }
  Node<T> *newNode=new Node<T>;
  newNode->next=pCur->next;
  newNode->data=value;
  pCur->next=newNode;
  this->length++;
  return OK;
}

// 遍历链表
template<typename T>
void Link<T>::link_foreach(void(print)(T *)){
  if(!print){
    return ;
  }
  Node<T> *pCur=this->head;
  for(int i=0;i<this->length;++i){
    pCur=pCur->next;
    print(pCur->data);
  }  
}

// 删除尾结点
template<typename T>
T* Link<T>::link_pop(){
  if(this->length==0)
    return NULL;
  Node<T> *pCur=this->head;
  for(int i=0;i<this->length;++i){
    pCur=pCur->next;
  }
  Node<T> *deleteNode=pCur;
  T *value=deleteNode->data;
  delete deleteNode;
  pCur=pCur->next;
  this->length--;
  return value;
}

// 插入尾结点
template<typename T>
int Link<T>::link_push(T *value){
  if(!value)
    return fail;
  Node<T> *pCur=this->head;
  for(int i=0;i<this->length;i++){
    pCur=pCur->next;
  }
  Node<T> *newNode=new Node<T>;
  newNode->data=value;
  newNode->next=NULL;
  pCur->next=newNode;
  this->length++;
  return OK;
}

// 删除头结点
template<typename T>
T * Link<T>::link_shift(){
  if(this->length==0)
    return NULL;
  Node<T> *pCur=this->head;
  T *value=pCur->next->data;
  Node<T> *deleteNode=pCur->next;
  pCur->next=deleteNode->next;
  delete deleteNode;
  this->length--;
  return value;
}

// 查找指定位置节点
template<typename T>
T * Link<T>::link_index(int index){
  if(index>this->length||index<0)
    return NULL;
  Node<T> *pCur=this->head->next;
  for(int i=0;i<index;++i){
    pCur=pCur->next;
  }
  return pCur->data;
}

// 添加头结点
template<typename T>
int Link<T>::link_unshift(T *value){
  if(!value)
    return fail;
  Node<T> *pCur=this->head;
  Node<T> *newNode=new Node<T>;
  newNode->data=value;
  newNode->next=pCur->next;
  pCur->next=newNode;
  this->length++;
  return OK;
}

// 查找节点 
template<typename T>
T * Link<T>::link_find(bool(print)(T *)){
  if(this->length==0||!print)
    return NULL;
  Node<T> *pCur=this->head->next;
  for(int i=0;i<this->length;i++){
    if(print(pCur->data)){
      return pCur->data;
    }
  }
  return NULL;
}

// 翻转链表
template<typename T>
int Link<T>::link_reverse(){
  if(this->length==0)
    return fail;
  Node<T> *pHead=this->head;
  Node<T> *pFont=NULL;
  Node<T> *pNext=NULL;
  while(pHead->next!=NULL){
    pFont=pHead->next;
    pHead->next=pFont->next;
    pFont->next=pNext;
    pNext=pFont;
  }
  this->head->next=pFont;
  return OK;
}

// 获取链表长度
template<typename T>
int Link<T>::link_length(){
  return this->length;
}

// 清空链表
template<typename T>
int Link<T>::link_clear(){
  if(this->length==0)
    return OK;
  Node<T> *pCur=this->head->next;
  for(int i=0;i<this->length;i++){
    Node<T> *t=pCur->next;
    if(!pCur)
      break;
    delete pCur;
    pCur=t;
  }
  this->length=0;
  return OK;
}

// 销毁链表
template<typename T>
int Link<T>::link_destory(){
  this->link_clear();
  if(this->head){
    delete this->head;
  }
  return OK;
}

// 连接链表
template<typename T>
Link<T>& Link<T>::operator+(const Link<T> &plink){
  Node<T> *pCur=this->head;
  for(int i=0;i<this->length;++i){
    pCur=pCur->next;
  }
  // pCur->next=plink.head->next;
  Node<T> *move=plink.head->next;
  Node<T> *newHead=new Node<T>;
  newHead->next=NULL;
  Node<T> *p=newHead;
  for(int i=0;i<plink.length;++i){
    Node<T> *newNode=new Node<T>;
    newNode->data=move->data;
    newNode->next=NULL;
    p->next=newNode;
    p=newNode;
    move=move->next;
  }
  pCur->next=newHead->next;
  this->length+=plink.length;
  delete newHead;
  return *this;
}

test.cpp

#include "link/link.cpp"
#include <iostream>
#include <string>
using namespace std;

struct person{
  int id;
  string name;
  int age;
};

int maxValue=-99;
int minValue=99;
struct person *pMax;
struct person *pMin;
template<typename T>
void myPrint(T *value){
  struct person *p=(struct person *)value;
  if(maxValue<p->age){
    maxValue=p->age;
    pMax=p;
  }
  if(minValue>p->age){
    minValue=p->age;
    pMin=p;
  }
  cout<<"id:"<<p->id<<" name:"<<p->name<<" age:"<<p->age<<endl;
}

template<typename T>
bool findPrint(T *value){
  struct person *p1=(struct person *)value;
  if(p1->age==20&&p1->id==3&&p1->name=="Sam"){
    return true;
  }else{
    return false;
  }
}

void test(){
  struct person p1={1,"Andy",18};
  struct person p2={2,"Tom",19};
  struct person p3={3,"Sam",20};
  struct person p4={4,"Tim",21};
  struct person p5={5,"Jack",22};
  Link<person> *k1=new Link<person>();
  k1->link_insert(0,&p1);
  k1->link_insert(0,&p2);
  k1->link_insert(0,&p3);
  k1->link_insert(0,&p4);
  k1->link_insert(0,&p5);
  k1->link_push(&p5);
  k1->link_unshift(&p3);
  // struct person *p=(struct person *)k1->link_shift();
  // cout<<"111id:"<<p->id<<" name:"<<p->name<<" age:"<<p->age<<endl;
  k1->link_foreach(myPrint);
  cout<<"max value. id:"<<pMax->id<<" name:"<<pMax->name<<" age:"<<pMax->age<<endl;
  cout<<"min value. id:"<<pMin->id<<" name:"<<pMin->name<<" age:"<<pMin->age<<endl;
  struct person *p=(struct person *)k1->link_find(findPrint);
  if(p)
  cout<<"find id:"<<p->id<<" name:"<<p->name<<" age:"<<p->age<<endl;
  cout<<k1->link_reverse()<<endl;
  cout<<"------------------"<<endl;
  k1->link_foreach(myPrint);
  k1->link_clear();
  k1->link_insert(0,&p1);
  k1->link_insert(0,&p2);
  k1->link_insert(0,&p3);
  k1->link_insert(0,&p4);
  k1->link_insert(0,&p5);
  k1->link_foreach(myPrint);
  cout<<k1->link_length()<<endl;
  cout<<"-------------------------------------"<<endl;
  Link<person> *k2=new Link<person>(*k1);
  k2->link_insert(0,&p1);
  k2->link_foreach(myPrint);
  cout<<"-------------------------------------"<<endl;
  k1->link_foreach(myPrint);

  *k1=*k1+*k2;
  cout<<"-------------------------------------"<<endl;
  k1->link_foreach(myPrint);
  k1->link_destory();
  cout<<"-------------------------------------"<<endl;
  cout<<"find id:"<<p5.id<<" name:"<<p5.name<<" age:"<<p5.age<<endl;
  // k2->link_foreach(myPrint);
  p=(struct person *)k2->link_index(0);
  cout<<"index id:"<<p->id<<" name:"<<p->name<<" age:"<<p->age<<endl;
  k2->link_destory();

}

int main(){
  test();
  system("pause");
  return EXIT_SUCCESS;
}

 运行结果

id:3 name:Sam age:20
id:5 name:Jack age:22
id:4 name:Tim age:21
id:3 name:Sam age:20
id:2 name:Tom age:19
id:1 name:Andy age:18
id:5 name:Jack age:22
max value. id:5 name:Jack age:22
min value. id:1 name:Andy age:18
find id:3 name:Sam age:20
1
------------------
id:5 name:Jack age:22
id:1 name:Andy age:18
id:2 name:Tom age:19
id:3 name:Sam age:20
id:4 name:Tim age:21
id:5 name:Jack age:22
id:3 name:Sam age:20
id:5 name:Jack age:22
id:4 name:Tim age:21
id:3 name:Sam age:20
id:2 name:Tom age:19
id:1 name:Andy age:18
5
-------------------------------------
id:1 name:Andy age:18
id:5 name:Jack age:22
id:4 name:Tim age:21
id:3 name:Sam age:20
id:2 name:Tom age:19
id:1 name:Andy age:18
-------------------------------------
id:5 name:Jack age:22
id:4 name:Tim age:21
id:3 name:Sam age:20
id:2 name:Tom age:19
id:1 name:Andy age:18
-------------------------------------
id:5 name:Jack age:22
id:4 name:Tim age:21
id:3 name:Sam age:20
id:2 name:Tom age:19
id:1 name:Andy age:18
id:1 name:Andy age:18
id:5 name:Jack age:22
id:4 name:Tim age:21
id:3 name:Sam age:20
id:2 name:Tom age:19
id:1 name:Andy age:18
-------------------------------------
find id:5 name:Jack age:22
index id:1 name:Andy age:18
请按任意键继续. . .

 

（；￣ェ￣）。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构C++实现单链表以及各种操作！
qq_58240448的博客
06-30 2820
使用c++实现的单链表以及各种操作，入插入、删除等！
C++实现单链表的各种操作（数据结构）
Ethereal的博客
10-27 1126
单链表的定义注意点，头指针和头结点的区别，用C++实现单链表的各种基本操作。
数据结构 - 反转单链表（C++）
热门推荐
了解➔熟悉➔掌握➔精通
02-18 6万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net /* * 反转单链表的循环算法（C++）- by Chimomo */ #include <iostream> #define NULL 0 using namespace std; struct Node { char data; Node *next; }; /** * Create single linke.
C++实现单链表（Single Linked List）
weixin_42133358的博客
05-14 7911
C++实现单链表（Single Linked List） 语言这个东西不用真的会忘， 我记得前前后后C++的基本语法我也看了好几遍了，一直没有动手写过什么东西，所以一遍遍的看，一遍遍的忘… … 正好最近在看数据结构，想着自己用C++来实现一下，一方面是熟悉整个逻辑过程，加深对数据结构的理解，另一方面，也熟悉一下C++。 单链表是线性表的链式存储结构，同顺序存储结构（可以理解为C++中的数组）不同的是，单链表在插入和删除一个结点时，不需要移动大量的元素，但是单链表没有数组中索引的概念，所以在查询一个元素
C++实现单链表
uxlike的博客
11-05 841
链表是一种以链式存储的线性表，由于内存空间可以不连续，使用十分灵活，与数组相比各有优缺点。 单链表需要有个标识指明起始位置以便于操作整个链表，可以是头指针也可以是头结点，只是实现上的不同，这里使用头结点的方式。
C++实现单链表的创建
weixin_46393892的博客
06-18 3649
单链表的定义 typedef struct linkList{ int data; struct linkList* next; }LNode; 单链表通常可以分为带头结点和不带头结点的单链表，二者的区别如下图所示 从上图可以直观地看到，带头结点的单链表相较于不带头结点的单链表在空间上会额外浪费一个结点。但是在引入头结点后，可以带来两个优点： ① 在处理第一个位置上的结点时，因为头结点的缘故，其处理方式和其他位置的结点操作一致，不需要进行特殊处理。 ② 无论链表是否为空，其头指针都指
C++实现单链表的基本操作
zhaicheng55的博客
12-27 998
【代码】C++实现单链表的基本操作。
数据结构——单链表基本操作实现 (c++)
weixin_74794504的博客
03-16 2575
单链表链式存储结构的特点是：用一组任意的存储单元存储线性表的数据元素（这里存储单元可以是连续的，也可以是不连续的），为了表示每个数据元素a与其直接后继数据元素之间的逻辑关系，除了存储信息本身外还要存储一个指示其直接后继的信息（地址）.这两部分信息组成数据元素a的存储映像称为结点，它包括两个域：存储信息的称为数据域，存储直接后继存储地址的域称为指针域，指针域中存储的信息称作指针或链。
数据结构 C++单链表的复制
ausfuture的博客
11-17 3277
数据结构 C++单链表的复制
C++数据结构之单链表
suren_jun的博客
09-14 1625
这里详细讲解了C++数据结构中的单链表的实现，采用了头节点存储数据和不存储数据两种方式对单链表的各种操作做了实现。
数据结构(7):查找
qq_64279967的博客
07-31 246
适用于线性表！适用于 有序的顺序表！就是 二分法！mid的值算出来如果是小数 就向下取整！大多时候是高的但不是全部插入一个元素8会导致所有的元素向后移动！代价太大 所以可以用链式存储！数据结构应该怎末设计？因该采取什么样的查找算法 都是需要大家按照现实遇到的需求做下的决定！！！中序遍历就是 左中右！可以写出递增的序列！
数据结构与算法--栈
wumingzei的博客
08-02 745
栈（Stack）是限定只能在表的一端进行插入和删除操作的线性表。允许插入和删除运算的一端称为栈顶（top），不允许插入和删除的另一端称为栈底（bottom）。在栈顶进行的插入操作称为入栈或进栈(push),在栈顶进行的删除操作称为出栈或退栈(pop)特点：后进先出（LIFO, Last In First Out）。栈的后进先出特性。顺序栈和链栈的入栈、出栈操作。栈在中缀表达式转换为后缀表达式中的应用。
【数据结构】——链式二叉树
2402_82668782的博客
08-02 671
1>二叉树的结构体 包含了数据和指向左右子树的指针}BTNode;<2>二叉树结点的创建<3>二叉树的创建Tip：二叉树是递归定义的，都可以单独看作 根、左子树、右子树。
数据结构(5.4_1)——树的存储结构
m0_65240792的博客
08-02 184
每个结点中保存指向双亲的“指针” 新增数据元素无需按逻辑上的次序存储，之家在上一个结点后添加新结点，并记录双亲结点 1、删除结点数据域 2、将尾部数据移动至删除结点位置填充空缺寻找其双亲结点相同的结点顺序存储各个节点，每个结点中保存孩子的链表头指针 树和二叉树的转化： 使用孩子兄弟表示法
数据结构——链式结构二叉树
2301_81888634的博客
08-02 491
我们已经学习了实现二叉树的两种方法：顺序结构（堆）和链式结构。敬请期待“二叉树OJ题”~
【C语言】【数据结构】冒泡排序及优化
2401_86272648的博客
08-02 127
冒泡排序是一种简单的排序算法。一次从前往后地走访待排序的元素序列被称为一趟，每一趟都会把相邻的两个元素的错误顺序交换，将当前趟次中最大或者最小的元素像“冒泡泡”一样冒到最后面，反复地走访元素序列，直到所有元素都排好序。
《数据结构》（C语言版）第1章 绪论（上）
m0_70617423的博客
07-29 1098
数据结构的研究内容 基本概念和术语
【数据结构入门 】栈
最新发布
KevinRay_0854的博客
08-02 398
通过构建一个栈，我们可以非常方便地实现后进先出的数据结构，使得我们能够高效地处理一些具有类似特性的问题。因此，了解和掌握栈的概念和操作是很重要的。在接下来的内容中，我们将详细介绍栈的基本原理、以及常见实现方式。希望通过本文的学习，读者能够深入理解栈，并能够在实际编程中熟练运用。
【数据结构】——二叉树OJ题
2302_78420373的博客
08-02 611
我们先想想二叉树我们学习了哪些内容再来做题哈其实学习二叉树重要的思想——递归，我们可以通过后面的题目慢慢的理解。
C++实现的数据结构教程
"该文档是关于数据结构的C++实现，涵盖了多种常用的数据结构，包括顺序表、单链表、双向链表、循环链表、顺序栈、链式栈、顺序队列、链式队列、优先级队列、串、二叉树、线索二叉树、堆、哈夫曼树、树、B+树和图，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值