C++实现单链表(含头结点)

最新推荐文章于 2023-02-23 17:16:16 发布
最新推荐文章于 2023-02-23 17:16:16 发布
阅读量4.1k 收藏 15
点赞数
分类专栏： 数据结构 文章标签： c++ null list delete search system
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/insistGoGo/article/details/6667246
版权
VS2005运行通过，如有问题，请各位大牛指正。

注意：单链表含有头结点

代码：

#include <iostream>
using namespace std;
template<class Type>
struct Node
{
	Type data;
	Node<Type> *next;
};
template<class Type>
class LinkList
{
protected:
	int len;//链表中结点个数
	Node<Type>* Head; //指向头结点
public:
	LinkList();//默认构造函数
	LinkList(const LinkList<Type>& otherList);//拷贝构造函数
	~LinkList();
	void createListForward();//头插法
	void createBackward();//尾插法
	void initList();//生成头结点，尾部设置为NULL
	bool isEmptyList();
	int length();
	void destoryList();
	void getFirstData(Type& firstItem);  
	void search(const Type searchItem);  
	void insertFirst(const Type newItem);  
	void insertLast(const Type newItem);  
	void insertBefore(const int pos,const Type newItem);  
	void insertAfter(const int pos,const Type newItem);  
	void deleteNode(const Type deleteItem);  
	void deleteNode(const int pos,Type& deleteItem);
	void reverse();
	const LinkList<Type>& operator=(const LinkList<Type>&otherList); 
	friend ostream& operator<< <>(ostream& cout,const LinkList<Type>& list);//注意 在<< 后加上 <>表明这是个函数模板
};

template<class Type>
LinkList<Type>::LinkList() //初始化时，只有一个头结点，有head指向
{
	Head = new Node<Type>;
	Head->next = NULL;
	len =0;
}

template<class Type>
LinkList<Type>::LinkList(const LinkList<Type>&otherList)
{
	//首先建立头结点
	Head = new Node<Type>;
	Head->next = NULL;
	len =0;
	Node<Type>* current = Head;//总是指向本链表的最后一个结点，待插入结点直接插入
	Node<Type>* otherListCurrent=otherList.Head->next;//otherListCurrent指向第一个元素
	while(otherListCurrent!=NULL)//拷贝的目标不为空
	{
		Node<Type>* newNode = new Node<Type>;
		newNode->data = otherListCurrent->data;
		newNode->next = current->next;
		current->next = newNode;
		current=current->next;
		otherListCurrent = otherListCurrent->next;
		len++;
	}

}

template<class Type>
const LinkList<Type>& LinkList<Type>::operator=(const LinkList<Type>&otherList)//赋值函数
{
	Node<Type>* current = Head;//current总是指向要插的位置
	Node<Type>* otherListCurrent=otherList.Head->next;//otherListCurrent指向第一个元素
	if (this!=&otherList)//避免自己给自己赋值
	{
		if (current->next!=NULL)
		{
			initList();//自己有结点，先销毁
		}
		while(otherListCurrent!=NULL)
		{
			Node<Type>* newNode = new Node<Type>;
			newNode->data = otherListCurrent->data;
			newNode->next = current->next;
			current->next = newNode;
			current=current->next;
			otherListCurrent = otherListCurrent->next;
			len++;
		}

	}
	return *this;//为了连续赋值
}

template<class Type>
LinkList<Type>::~LinkList()
{
	destoryList();
}

template<class Type>
void LinkList<Type>::createListForward()//头插法
{
	Node<Type>* newNode;
	cout<<"输入链表长度:"<<endl;
	cin>>len;
	for (int i=0;i<len;i++)
	{
		newNode = new Node<Type>;
		cout<<"输入元素:"<<endl;
		cin>>newNode->data;
		newNode->next=Head->next;
		Head->next = newNode; //每插入一个结点，都是要把它放在第一个结点的位置
	}
}

template<class Type>
void LinkList<Type>::createBackward()//尾插法
{
	Node<Type>* current = Head;//current指向头结点
	Node<Type>* newNode;
	cout<<"输入链表长度:"<<endl;
	cin>>len;
	for (int i=0;i<len;i++)
	{
		newNode = new Node<Type>;
		cout<<"输入元素:"<<endl;
		cin>>newNode->data;
		newNode->next = current->next;
		current->next = newNode;
		current=current->next;
	}
}

template<class Type>
void LinkList<Type>::initList() //所有结点都销毁
{
	destoryList();
	Head = new Node<Type>;
	Head->next = NULL;
	len =0;
}

template<class Type>
bool LinkList<Type>::isEmptyList()
{
	if (Head->next==NULL)
	{
		return true;
	}
	else
	{
		return false;
	}
}

template<class Type>
int LinkList<Type>::length()
{
	return len;
}

template<class Type>
void LinkList<Type>::destoryList()//销毁包括头结点
{
	Node<Type>* current;
	while(Head!=NULL)
	{
		current = Head;
		Head = current->next;
		delete current;
	}
	Head=NULL;
	len=0;
}

template<class Type>
void LinkList<Type>::getFirstData(Type& firstItem)
{
	if (!isEmptyList())
	{
		firstItem = (Head->next)->data;
	}
	else
	{
		cout<<"链表为空!"<<endl;
	}
}

template<class Type>
void LinkList<Type>::search(const Type searchItem)
{
	Node<Type>* current;
	if (isEmptyList())
	{
		cout<<"List is Empty"<<endl;
	}
	else
	{
		current = Head->next;//越过头结点，指向第一个元素
		while (current!=NULL && current->data!=searchElement)
		{
			current = current->next;
		}
		if (current!=NULL)
		{
			cout<<"Item is Found in the list"<<endl;
		}
		else
		{
			cout<<"Item is not Found in the list"<<endl;
		}
	}
}

template<class Type>
void LinkList<Type>::insertFirst(const Type newItem)
{
	Node<Type> *newNode = new Node<Type>;
	newNode->data = newItem;
	newNode->next = Head->next;
	Head->next = newNode;
}

template<class Type>
void LinkList<Type>::insertLast(const Type newItem)
{
	Node<Type> *newNode = new Node<Type>;
	newNode->data = newItem;
	Node<Type>* current = Head;  //寻找位置
	while (current->next != NULL)  
	{  
		current = current ->next;  
	}  
	newNode->next = current->next;
	current->next = newNode;
}

template<class Type>
void LinkList<Type>::insertBefore(const int pos,const Type newItem)
{
	int i=1;  
	Node<Type>* current = Head->next;  
	if (pos<1 || pos>len)  
	{  
		cout<<"插入位置不正确!"<<endl;  
		return;  
	}  
	Node<Type>* newNode = new Node<Type>;  
	newNode->data = newItem;  
	if (1==pos)  
	{  
		newNode->next = Head->next;  
		Head->next = newNode;  
	}  
	else  
	{  
		while(i<pos-1)  
		{  
			current = current->next;  
			i++;  
		}  
		newNode->next = current->next;  
		current->next = newNode;  
	}  
	len++; 
}

template<class Type>
void LinkList<Type>::insertAfter(const int pos,const Type newItem)
{
	int i=1;  
	Node<Type>* current = Head->next;//current指向第一个位置，和i配合，指向第i个结点   
	if (pos<1 || pos>len)  
	{  
		cout<<"插入位置不正确!"<<endl;  
		return;  
	}  
	Node<Type>* newNode = new Node<Type>;  
	newNode->data = newItem;  
	while(i<pos)  
	{  
		current = current->next;  
		i++;  
	}  
	newNode->next = current->next;  
	current->next = newNode;  
	len++; 
}

template<class Type>
void LinkList<Type>::deleteNode(const Type deleteItem)
{
	Node<Type>* current=Head -> next;
	Node<Type>* trailCurrent = Head;//指向current前面的结点
	if (isEmptyList())
	{
		cout<<"List is Empty"<<endl;
	}
	else
	{
		while (current!=NULL && current->data!=deleteItem)
		{
			trailCurrent = current;
			current=current->next;
		}
		if (current==NULL)
		{
			cout<<deleteItem<<" is not Found in the list"<<endl;
		}
		else
		{
			trailCurrent->next = current->next;
			delete current;
			cout<<deleteItem<<" is delete in the list"<<endl;
			len--;
		}
	}
}

template<class Type>
void LinkList<Type>::deleteNode(const int pos,Type& deleteItem)
{
	int i=1;  
	Node<Type>* current = Head;  
	Node<Type>* temp;  
	if (pos<1 || pos>len)  
	{  
		cout<<"删除位置不正确!"<<endl;  
		deleteItem = -1;  
		return;  
	}  
	while(i<pos)  
	{  
		current = current->next;  
		i++;  
	}  
	temp = current->next;  
	current->next = temp->next;  
	deleteItem = temp->data;  
	delete temp;  
	len--;  

}

template<class Type>
void LinkList<Type>::reverse()
{
	Node<Type>* current = Head->next;
	Head->next=NULL;
	if (current==NULL)
	{
		cout<<"链表为空!"<<endl;
	}
	else
	{
		while (current!=NULL)
		{
			Node<Type>* nextCurrent = current->next;
			current->next = Head->next;
			Head->next=current;
			current = nextCurrent;
		}
	}
}

template<class Type>
ostream& operator<< (ostream& cout,const LinkList<Type>& list)
{
	Node<Type>*current=list.Head->next; //有头结点，这是current指向第一个结点
	if (current!=NULL)
	{
		while (current!=NULL)
		{
			cout<<current->data<<endl;
			current=current->next;
		}
	}
	else
	{
		cout<<"链表为空!"<<endl;
	}
	return cout;
}
void main()
{
	LinkList<int> list1;
	list1.createBackward();
	list1.reverse();
	cout<<list1;
	system("pause");
}

 

 

insistGoGo
关注
专栏目录
C/C++语言实现单链表（带头结点）
weixin_34355881的博客
02-22 469
彻底理解链表中为何使用二级指针或者一级指针的引用 数据结构之链表-链表实现及常用操作(C++篇) 　　C语言实现单链表，主要功能为空链表创建，链表初始化（头插法），链表元素读取，按位置插入，（有序链表）按值插入，按位置删除，按值删除，清空链表，销毁链表。 　　关键思路：（1）将结点创建结构体；（2）链表中添加头结点，以便统一操作；（3）使用结点一级指针和二级指针的异同点；（4）链表的...
C++实现单链表：带头结点
weixin_44915226的博客
06-17 333
基本功能 初始化单链表 建立单链表：头插法和尾插法 遍历单链表 按位序查找元素 按值查找元素 按位序插入结点 按位序删除结点 求单链表长度   代码 #include <iostream> #include <stdlib.h> using namespace std; typedef int ElemType; //定义单链表结点 typedef struct LNode{ ElemType data; struct LNode *next; }LNode
C++分别创建和显示带头结点与不带头结点的单链表
03-19
最近在学数据结构，自己写的很简单的小程序，积跬步、至千里。
单链表（带头结点）（C/C++）
沉默安的博客
07-30 184
//带头结点的单链表 #include<stdio.h> #include<stdlib.h> typedef int Elemtype; typedef int Status; //创建单链表结点 typedef struct LNode { Elemtype data; struct LNode* next; }LNode, * LinkList; //对单链表进行初始化 bool InitList(LinkList& L) { L = (LNode*)mal
C++单链表的创建（有头结点）
Moon_yao的博客
03-26 2398
c++单链表的创建（有头结点）
C++实现带头结点单链表
adminlpx的博客
10-29 2039
单链表属于基本数据结构中的线性结构，它应用于很多数据结构中，例如栈，队列等，作用广泛。在数据结构中我们习惯把关于单链表的一系列操作制作为一个ADT(Abstract Data Type)使用，在C++中把它封装为一个类，使用起来更是方便。 关于单链表的操作包括插入（包括头插和尾插）、删除、查找、检查是否有环、环的长度、环的入口等操作。以下就是我的代码实现： 每个结点的数据类型应该是一个结构体类
C++ 单链表（带头结点）
m0_47360158的博客
07-02 372
C++ 单链表（带头结点）
C++实现单链表删除倒数第k个节点的方法
08-30
本文将详细介绍C++实现单链表删除倒数第k个节点的方法，并结合实例形式分析了C++单链表的定义、遍历及删除相关操作技巧。 单链表结构定义 在C++中，单链表可以使用结构体来定义，每个节点包含一个数据域和一个指向...
单链表（带头结点）.cpp
08-01
实现单链表及其一些基本操作函数（带头结点） 1.头文件包含 2.宏定义及节点类型描述 3.初始化、判断是否为空 4.指定位置插入操作 5.在p节点后插入元素e 6.在p节点前插入元素e 7.删除操作：删除第i个节点，元素...
【数据结构与算法 C/C++】单链表的实现 (虚拟头结点)
qq_45596525的博客
04-02 2736
单链表 文章目录单链表一、数据结构定义二、特点与说明1. 头指针与头结点三、数据结构与操作1.结构定义2.操作(1) 初始化(2)插入(3)删除四、仓库地址 提示：以下是本篇文章正文内容，下面案例可供参考 一、数据结构定义 单链表是由若干个链表结点构成的, 每个结点除了需要存储自身节点外, 还需要存储后继结点的地址 结点定义为 typedef struct ListNode{ // 数据元素 int data; // 指针域,指向下一个结点 struct ListNode
C++之创建链表带头节点、不带头节点
最新发布
云霄IT的博客
02-23 1245
【代码】C++之创建链表带头节点、不带头节点。
数据结构 | C++建立带头结点的单链表、使用头插法插入数据
余弦的鱼塘
10-31 3271
最近在考研复习，看的王道的书，但是书里【用头插法建立带头结点的单链表】用的C语言和C++的混合用法，对于没学C直接C++的我，看起来非常吃力，于是自己写了纯C++的代码。 我用Node类和List类来实现单链表，其中Node类不一定用class，可以用struct来替代，因为该类没有函数要调用；List类有函数，所以用class不用strcut。 头结点的实现是在List的构造函数里，创建一个头结点，并且让head指针指向这个头结点。（head指针相当于有些教材中说的first指针）。使用头结点可以让头插.
带头结点的单链表转置
yp18792574062的博客
12-02 1734
带头结点的单链表转置
c++模板链表实现
invisible_sky的博客
03-24 2394
简介：主要是利用模板实现链表的操作。模板的使用，使得程序的开发量大大地减少。 可以先定义一个链表LinkList，之后可以定义自己的类了（例如：Student类），使用时就可以这样调用了 LinkList  L； 下面便是链表的实现： LinkList.cpp template struct Node { Type data; struct Node *next; }; templ
带头结点的链表头插法C++实现
CppPlayer
11-07 2442
#include using namespace std; //带头结点的头插法实现链表 typedef int DATA; struct SNode { DATA data; SNode* pNext; }; struct SList { SNode* m_pHead; SList() { m_pHead = new
C/C++中创建(带头结点、不带头结点的)单链表（图解版）
qq_41624560的博客
05-29 898
https://blog.csdn.net/weixin_43193864/article/details/105846546
C++模板实现泛型链表
心清的专栏
08-18 2125
链表是一个比较基础的数据结构，也是理解其他数据结构和算法和基础。传统C实现的链表其代码复用性比较差，其在C++中，list是对链表的一个通用实现。本文作者也尝试了用模板来实现一个通用型的链表，下面给出代码，以供参考，如有错误，请联系笔者改正。 首先利用C++模板实现一个链表的结点数据结构，其实现如下： 在头文件node.h中： #pragma once #ifndef __UNIT #d
C++模板实现的单向链表
eskimoer的专栏
02-27 2553
C++模板实现的单向链表，实现了链表的初始化创建，元素插入，元素链表末尾添加，元素删除，链表清空 //Lists.h #ifndef DDXXLISTS_H #define DDXXLISTS_H #include using namespace std; template class Lists { public: Lists(); Lists(int nSize); ~Lists(
C++实现循环链表
思考，思考，再思考~
08-07 9324
C++实现循环链表
C++实现单链表：结点描述与初始化
在单链表的实现中，通常会添加一个头结点，它的主要作用是在链表头部进行插入和删除操作时提供便利。头结点的类型可以与数据结点相同，也可以不同，这里假设它们是相同的。有时，头结点可以包含额外的信息，如指向...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值