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

已于 2022-04-07 17:50:45 修改
阅读量1.7k 收藏 6
点赞数 2
分类专栏： 数据结构C++实现 文章标签： c++ 数据结构 链表
于 2022-03-17 14:36:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Brillian123/article/details/123549646
版权

本文的链表实现使用的是c++的类模板，构造节点类模板Node<T>和链表类模板LinkedList<T>。原因是实用类模板可以适用于各种基本数据类型。以下是类模板及其接口（存放在"LinkedList.h"头文件中）：

#ifndef LINKEDLIST_H_
#define LINKEDLIST_H_

#include<iostream>
using namespace std;

//Node类模板的友元类模板声明
template <typename T>
class LinkedList;  //LinkedList作为Node类的友元类用于访问Node类的私有属性。在Node类前面加上LinkedList的声明，让编译器不报错
		
				   //注意：class LinkedList{};     这里的{}不能要。只是声明，不需要{}。

//Node类模板
template <typename T>
class Node
{
public:
	//node *head  = new node();
	Node *d_next; //指针段：指向下一个节点的指针
	T d_data; //数据段：本节点的数据

public:
	Node();//默认构造
	Node(const T &elem);//有参构造
	~Node();//析构函数
	
	//对于Node数据的类型，cout无法直接通过输出node对象来输出数据d_data，所以需要重载<<运算符实现。同时要访问Node节点的私有属性，要声明是友元函数
	template <typename R>
	friend std::ostream& operator<<(std::ostream &,  Node<R> &);  //第二个参数不能用const修饰引用，会报错
};




template <typename T>
class LinkedList 
{
private:
	//头指针
	Node<T>* d_head;  //指针指向的类型为Node<T>

	//节点数
	int d_size;

public:
	//默认构造（空链表）
	LinkedList();

	//析构
	~LinkedList();

	//尾端插入节点
	void push_back(const T &val);


	//打印链表
	template <typename R>
	friend std::ostream & operator<<(std::ostream &out, LinkedList<R> &list);
	
	//获取链表长度
	int size()
	{
		return d_size;
	}

	//头部插入节点
	void push_head(const T &val);

	//在指定位置插入节点
	void insert(const T &val,int pos);

	//删除所有数据
	void DeleteAll();

	//查找某元素并返回其节点地址
	Node<T> * Find(const T &val);
	//按元素删除节点
	void DeleteElem(const T &val);

	//尾部删除
	void DeleteLast();

	//第一个节点删除
	void DeleteFirst();

	//链表反转
	void Reserve();
};

#endif

下面是类模板接口的实现（存放在linkedList.cpp文件中）：

#include<iostream>
#include "LinkedList.h"
//Node无参构造
template <class T>
Node<T>::Node() : d_data(), d_next(nullptr) {} //参数列表法实现默认构造，数据赋值为空，指向下一个节点的指针赋空指针

//Node有参构造
template <class T>
Node<T>::Node(const T &elem)
{
	this->d_data = elem;
	this->d_next = nullptr;
}

//Node析构函数
template <class T>
Node<T>::~Node(){}


//Node类模板中重载运算度算
template <typename R>
std::ostream& operator<<(std::ostream &out,  Node<R> &nod) //重载运算度算是一个友元的全局函数，不需要加作用域。第二个参数不能加const
{
	out << nod.elem();
	return out;
}

//LinkedList类模板的默认构造
template <typename T>
LinkedList<T>::LinkedList()  //默认构造长度为0的链表
{
	this->d_head = new Node<T>();//开辟头节点。头结点啥也不存，也不一定必须有，不计入链表长度，但我这里假设有头结点。
	this->d_head->d_data = NULL;//该节点的数据初值为NULL
	this->d_head->d_next = nullptr;//末指针设为空
	this->d_size = 0;

}   

//LinkedList类模板析构函数
template <typename T>
LinkedList<T>::~LinkedList()
{

	if (this->size()==0)
	{
		delete this->d_head;
	}
	else
	{
		Node<T> *tmp=nullptr;
		Node<T> *cur = this->d_head->d_next;//指向第一个节点
		while (cur->d_next != nullptr)//不是尾节点时
		{
			tmp = cur;
			cur = cur->d_next;//光标节点指向下一个节点
			delete tmp;//释放当前节点
		}
		delete cur;//释放尾节点
		delete this->d_head;//释放头结点
	}

}

template <typename T>
void LinkedList<T>::push_back(const T &val)//尾插
{
	Node<T> * tmp = new Node<T>(); //Node的有参构造
	tmp->d_data = val;
	tmp->d_next = nullptr;

	Node<T> *cur = this->d_head;//设置光标指针

	if (cur->d_next == nullptr)//如果只有头结点
	{
		cur->d_next = tmp;//头结点直接连接插入数据所创建的新节点
	}
	else 
	{
		while (cur->d_next != nullptr)//如果有其他节点
		{
			cur = cur->d_next;//更新光标开始遍历所有非尾节点
		}
		cur->d_next = tmp;//尾节点连接上插入数据的节点
	}
	d_size++; //节点个数加1
}

template <typename T>
void LinkedList<T>::push_head(const T &val)//头插
{
	Node<T> * tmp = new Node<T>(); //Node的有参构造
	tmp->d_data = val;
	tmp->d_next = nullptr;

	Node<T> *cur = this->d_head;	
	if (cur->d_next == nullptr)//如果只有头结点
	{
		cur->d_next = tmp;
	}
	else
	{
		tmp->d_next = this->d_head->d_next;//插入节点链接原来的第一个节点
		this->d_head->d_next = tmp;//头结点链接插入的节点
	}

	d_size++; //节点个数加1
}


template <typename T>
void LinkedList<T>::insert(const T &val, int pos)  //pos位置插入val
{
	Node<T> *tmp = new Node<T>();
	tmp->d_data = val;
	tmp->d_next = nullptr;
	if (pos == 0||this->d_size==0)//约定链表下标从0开始算
	{
		this->push_head(val);
		this->d_size++;
	}
	else if (pos == this->d_size)//尾插
	{
		this->push_back(val);
		this->d_size++;
	}
	else if (pos > 0 && pos < this->d_size)
	{
		Node<T> *cur = this->d_head;
		for (int i = 0; i < pos; i++)
		{
			cur = cur->d_next;
		}
		tmp->d_next = cur->d_next;
		cur->d_next = tmp;
		this->d_size++;
	}
	else
	{
		cout << "输入的位置有误！！！" << endl;
	}
}

template <typename T>
void LinkedList<T>::DeleteAll()//清空除了头结点外所有的节点
{
	if (this->d_size==0) //如果
	{
		cout << "链表已是空链表" << endl;			
	}
	else
	{
		Node<T>* cur = this->d_head->d_next;
		Node<T>* tmp = nullptr;
		while (cur->d_next != nullptr)//释放尾节点前的节点
		{
			tmp = cur;
			cur = cur->d_next;
			delete tmp;
		}
		delete cur;//释放尾节点
		this->d_head->d_next = nullptr;//空链表，头结点的指针为nullptr
		this->d_size = 0;//长度置0
	}
}

template <typename R>
std::ostream & operator<<(std::ostream &out, LinkedList<R> &list)//友元函数，重载<<运算符用于输出链表
{

	if (list.d_size==0)
	{
		out << "链表为空"<<endl;
	}
	else
	{
		Node<R> * cur = list.d_head->d_next;//光标处于第一个节点
		while (cur->d_next != nullptr)
		{

			out << cur->d_data << "-->";//输出光标所在节点的数据
			cur = cur->d_next;//光标更新，指向下一节点
		}
		out<<cur->d_data << "-->";//输出最后节点的数据
	}


	out << "&"<<endl;//输出结尾指向的空，用&表示
	return out;
}


template <typename T>
Node<T>* LinkedList<T>::Find(const T &val)
{
	if (this->d_size == 0)
	{
		cout << "空链表！！" << endl; 
		return nullptr;
	}
	else
	{
		Node<T>* cur = this->d_head->d_next;//光标处于第一个节点
		while (cur !=nullptr)//还没遍历所有节点（若最后一个节点也没找到，则cur更新后给nullptr，退出循环）
								//while (cur !=nullptr)可以遍历所有节点
			                    //while (cur->d_next != nullptr)会在最后一个节点处退出循环
		{
			if (cur->d_data == val)
			{
				cout << "找到了" << val << endl;
				return cur;
			}
			cur = cur->d_next;
		}
		cout << "未找到" << val << endl;
		return nullptr;//未找到

	}

}

template <typename T>
void LinkedList<T>::DeleteElem(const T &val)//按值删除节点
{
	Node<T>* tmp = this->Find(val);
	if (tmp == nullptr)
	{
		cout << "不存在" << val << "，无法删除！" << endl;
	}
	else
	{
		Node<T>* cur = this->d_head;

		while (cur->d_next != tmp)//寻找元素所在的节点
		{
			cur  = cur->d_next;
		}
		cur->d_next = tmp->d_next;
		delete tmp;
		tmp = nullptr;
		this->d_size--;
	}

}

template <typename T>
void LinkedList<T>::DeleteLast()//尾删
{
	if (this->d_head->d_next == nullptr)
	{
		cout << "空链表，无法删除最后一个元素" << endl;
	}
	Node<T>* cur = this->d_head->d_next;
	Node<T>* tmp = nullptr;

	while (cur->d_next != nullptr)//不是最后一个节点
	{
		tmp = cur;
		cur = cur->d_next;
	}
	
	//到最后一个节点,tmp指向第二个节点
	delete cur;
	tmp->d_next = nullptr; //倒数第二个节点变为尾节点，其d_next为nullptr
	this->d_size--;
}

template <typename T>
void LinkedList<T>::DeleteFirst()
{
	if (this->d_size==0)
	{
		cout << "空链表，无法删除第一个元素" << endl;
	}
	else
	{
		Node<T>* tmp = this->d_head->d_next;//光标处于第一个节点
		this->d_head->d_next = tmp->d_next;
		delete tmp;
		tmp = nullptr;
		this->d_size--;
	}
}


template <typename T>
void LinkedList<T>::Reserve()
{
	if (this->d_size == 0)
	{
		cout << "链表为空，不需要反转" << endl;
	}
	else if (this->d_size == 1)
	{
		cout << "链表长度为1，不需要反转" << endl;
	}
	else
	{
		Node<T>* pre;
		Node<T>* cur;
		Node<T>* latter;
		pre = nullptr;//pre在链表末尾的nullptr位置
		cur = this->d_head->d_next;//cur指向第一个节点
		latter = cur->d_next;//latter指向第二个节点
		while (latter->d_next != nullptr)
		{
			cur->d_next = pre;
			pre = cur;
			cur = latter;
			latter = latter->d_next;
		}
		latter->d_next = cur;
		cur->d_next = pre;
		this->d_head->d_next = latter;

	}


}


void test02()
{
	LinkedList<int> List1; //默认构造
	cout << List1.size() << endl;
	cout << List1 << endl;
	//测试push_back
	int num = 2;
	List1.push_back(num);
	List1.push_back(3);
	cout << List1 << endl;

	List1.push_head(0);
	List1.push_head(-1);
	cout << List1 << endl;

	List1.insert(-2,4);
	cout << List1 << endl;

	List1.DeleteAll();
	cout << List1 << endl;
	List1.DeleteAll();

	List1.Find(2);
	List1.push_head(0);
	List1.push_head(1);
	List1.push_head(2);
	List1.push_head(4);
	List1.push_head(10);
	cout << List1 << endl;
	List1.Find(2);
	List1.Find(100);
	List1.Find(0);

	cout << List1 << endl;
	List1.DeleteElem(3);
	List1.DeleteElem(0);
	cout << List1 << endl;

	List1.DeleteLast();
	cout << List1 << endl;
	List1.DeleteLast();
	cout << List1 << endl;

	List1.DeleteFirst();
	cout << List1 << endl;
	List1.DeleteFirst();
	cout << List1 << endl;

	List1.DeleteFirst();
	cout << List1 << endl;

	List1.push_back(7);
	List1.push_back(8);
	List1.push_back(9); 
	List1.push_back(10);
	cout << List1 << endl;
	List1.Reserve();//链表反转
	cout << List1 << endl;


}

using namespace std;
int main()
{
	test02();
	return 0;
}

对于链表反转，思路参考下图

 具体代码：

template <typename T>
void LinkedList<T>::Reserve()
{
	if (this->d_size == 0)
	{
		cout << "链表为空，不需要反转" << endl;
	}
	else if (this->d_size == 1)
	{
		cout << "链表长度为1，不需要反转" << endl;
	}
	else
	{
		Node<T>* pre;
		Node<T>* cur;
		Node<T>* latter;
		pre = nullptr;//pre在链表末尾的nullptr位置
		cur = this->d_head->d_next;//cur指向第一个节点
		latter = cur->d_next;//latter指向第二个节点
		while (latter->d_next != nullptr)
		{
			cur->d_next = pre;
			pre = cur;
			cur = latter;
			latter = latter->d_next;
		}
		latter->d_next = cur;
		cur->d_next = pre;
		this->d_head->d_next = latter;

	}

}

程序运行结果：

只需倾听
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++实现单向链表
01-16
单向链表是一种基本的数据...通过这个项目，你不仅可以学习到如何在C和C++中实现单向链表的基本操作，还能理解指针、动态内存分配以及链式数据结构的工作原理。对于初学者来说，这是对数据结构和算法基础的重要实践。
数据结构与算法:单向链表实现与封装
08-26
"数据结构与算法：单向链表实现与封装" 在计算机科学中，数据结构是指计算机中存储、组织和管理数据的方式。链表是一种基本的数据结构，单向链表是指链表中的每个节点 chỉ指向下一个节点的数据结构。今天，我们将...
C++链表类及链表常用功能实现
chenyr0021
03-03 8249
使用C++编写链表类，实现以下功能： 建立链表 删除链表 插入元素（链表尾部或者指定位置） 删除元素（指定位置） 查找第K个元素 查找某个元素值是否存在 逆序链表 为了使链表可以用于不同数据类型，因此使用了模板类。 1，节点类 链表的每个节点都是一个独立的单元，每个单元由数据和指向下一节点的指针构成 //定义链表节点 template &amp;amp;lt;class T&amp;amp;gt; class Node {...
数据结构之单向链表类（C++实现）
o707191418的博客
06-17 983
Definition.h // 链表节点定义 typedef struct _ListNode { _ListNode* next; int data; }ListNode; List.h #include <iostream> #include <stack> #include "Definition.h" // 链表定义及链表类 class List { public: List(); //默认构造函数 List(const List& ls); //拷贝构
C C++最新链表（基础详解、实现、OJ笔试题），2024年最新写给程序员的Flutter详细教程
最新发布
2401_84976104的博客
05-15 648
链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。非连续的意思就是链表的每一部分可以在内存的任意一块区域存在，且这块区域的地址是随机的，所以一般用动态内存来开辟这块空间的地址。数据域和指针域，通过指针域即可访问其他结点的数据。
:Node<T>* & fun( Node<T>* & p );这里同时用*和&有什么作用?
疾风剑豪
04-21 1147
我在数据结构中的树的实现经常用到如下方式: Node<T>*&fun(Node<T>*&p); 请问它和:Node<T>*fun(Node<T>*p); Node<T>&fun(Node<T>&p); 的使用有什么不同?请分别从形参和返回值两...
链表的一些操作2
weixin_42223701的博客
09-30 109
链表的一些操作2 package lianbiao; public class Link<T> { private Node<T> root;//链表的根节点 private int foot;//表示链表结点的索引 private int count;//对添加数据进行计数 private class Node<T>{ private T data; private Node nextNode;
c++实现单链表（通俗易懂）
blankers的博客
05-17 648
链表，可以将之理解为一种结构体指针数据类型。c++的实现方式和c相比没有什么太大的区别。 首先定义一个结构体， struct node { int data; node *next; }; typedef node* List; 这里data用于储存数据，node *next用于指向下一节点的地址。 由于我们平常使用的都是结构体的指针，这里就自定义一个数据类型List，用于表示链表。 创建一个链表 //创建一个单链表 void creat_List(List a,int length) {
C++实现简单单向链表
08-19
"C++实现简单单向链表" 以下是对C++实现简单单向链表的详细知识点： 一、链表的概念 链表是一种常用的数据结构，通过指针将多个节点连接起来，每个节点包含一个值和一个指向下一个节点的指针。链表可以用于实现...
C语言数据结构旋转链表的实现
08-29
以下是一个C++实现的示例代码，虽然不是纯C语言，但思路和逻辑与C语言类似： ```cpp class ListNode { public: int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; class Solution { public...
C++数据结构之--单向链表（SingleList）
who_I_am__的博客
08-18 799
C++单向链表, 查找,头部添加,尾部添加,删除反转等功能.
单链表的C++实现。。
08-23
数据结构上机实验课题之一，要求实现单链表的插入排序等功能。
【 数据结构 】单链表的实现 - 详解（C语言版）
热门推荐
上上谦. 的博客
03-22 1万+
前言 简单用C语言来描述数据结构中的单链表，本文实现的只是简单的无头单链表，包括单链表的增加数据，删除数据，查找指定数据，修改指定数据，也就是简单的增删查改等操作。
【C++】单向链表
taoxing
07-09 1450
一.基本介绍 单向链表是链表中的一种，它链接的方向是单向的，而且对链表的访问要从头部开始，依次往下读取。 一个单向链表的节点被分为两部分，第一部分保存该节点的相关信息，第二个节点存储下一个节点的地址。 链表中节点的地址是不连续的。 实现思路： （1）我们需要实现两个类，一个类为节点类，存储相关信息与下一个节点的地址；一个为链表类，头节点作为其变量。 （2）在这里我们以学生信息作为节点进行实现，基本信息包括学号、姓名（写的简洁一下）。 （3）单链表包括节点的增删查改以及链表的打印。 单链
C++实现单链表（Single Linked List）
weixin_42133358的博客
05-14 7877
C++实现单链表（Single Linked List） 语言这个东西不用真的会忘， 我记得前前后后C++的基本语法我也看了好几遍了，一直没有动手写过什么东西，所以一遍遍的看，一遍遍的忘… … 正好最近在看数据结构，想着自己用C++来实现一下，一方面是熟悉整个逻辑过程，加深对数据结构的理解，另一方面，也熟悉一下C++。 单链表是线性表的链式存储结构，同顺序存储结构（可以理解为C++中的数组）不同的是，单链表在插入和删除一个结点时，不需要移动大量的元素，但是单链表没有数组中索引的概念，所以在查询一个元素
单向链表实现（C语言）
li
06-11 1412
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 ...
数据结构——链表（c++ 实现）
weixin_43211535的博客
10-24 663
一.静态链表 静态链表没有指针但是也可以实现链表的结构，可以通过数组来实现，如下图所示，头结点数为1，说明下一个指向1；然后1的头结点数是4，下一个元素便指向4号，4号的头结点数为2.。。。。。 一.单链表 代码实例： #include<stdlib.h> #include<iostream> using namespace std; cla...
c++ 链表_C语言实现链表（链式存储结构）
weixin_39719165的博客
11-23 1021
链表（链式存储结构）及创建链表，别名链式存储结构或单链表，用于存储逻辑关系为 "一对一" 的数据。与顺序表不同，链表不限制数据的物理存储状态，换句话说，使用链表存储的数据元素，其物理存储位置是随机的。例如，使用链表存储 {1,2,3}，数据的物理存储状态如下图所示： 我们看到，上图 根本无法体现出各数据之间的逻辑关系。对此，链表的解决方案是，每个数据元素在存储时都配备一个指针，用于指向自己的直...
C++ 入门算法，新手必看之：单向“链表”（一）
cpp_learner的博客
03-22 4448
俗话说得好，不懂链表的程序员，不配称为C/C++程序员。 为什么呢？ 链表的存储主要依据指针来实现，而指针又是C/C++独有的特性，是其他语言没有的。 今天，你点进来看了这篇博客，说明你还是不懂C/C++当中链表的算法。 不懂没关系，看了这篇博客，只要是懂得指针的小伙伴，都会学会使用单向链表。 链表是什么？ 链表是线性表的链式存储方式，逻辑上相邻的数据在计算机内的存储位置不必须相邻，那么，怎么表...
数据结构双向链表c++
03-31
双向链表是一种常见的数据结构，与单向链表相比，它每个节点都有两个指针，分别指向前驱节点和后继节点。这样，双向链表可以实现双向遍历，插入和删除操作也更加方便。 以下是用C语言实现双向链表的代码： ```c #include <stdio.h> #include <stdlib.h> // 双向链表节点结构体 typedef struct ListNode { int val; struct ListNode *prev; struct ListNode *next; } ListNode; // 创建双向链表节点 ListNode *createNode(int val) { ListNode *node = (ListNode *)malloc(sizeof(ListNode)); node->val = val; node->prev = NULL; node->next = NULL; return node; } // 插入节点到双向链表头部 ListNode *insertAtHead(ListNode *head, int val) { ListNode *node = createNode(val); if (head == NULL) { head = node; } else { node->next = head; head->prev = node; head = node; } return head; } // 插入节点到双向链表尾部 ListNode *insertAtTail(ListNode *head, int val) { ListNode *node = createNode(val); if (head == NULL) { head = node; } else { ListNode *cur = head; while (cur->next != NULL) { cur = cur->next; } cur->next = node; node->prev = cur; } return head; } // 删除双向链表中的节点 ListNode *deleteNode(ListNode *head, int val) { if (head == NULL) { return NULL; } ListNode *cur = head; while (cur != NULL && cur->val != val) { cur = cur->next; } if (cur == NULL) { return head; } if (cur == head) { head = head->next; if (head != NULL) { head->prev = NULL; } } else { cur->prev->next = cur->next; if (cur->next != NULL) { cur->next->prev = cur->prev; } } free(cur); return head; } // 打印双向链表 void printList(ListNode *head) { while (head != NULL) { printf("%d ", head->val); head = head->next; } printf("\n"); } // 主函数 int main() { ListNode *head = NULL; head = insertAtHead(head, 1); head = insertAtHead(head, 2); head = insertAtTail(head, 3); printList(head); // 2 1 3 head = deleteNode(head, 2); printList(head); // 1 3 head = deleteNode(head, 3); printList(head); // 1 head = deleteNode(head, 1); printList(head); // return 0; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值