单链表

最新推荐文章于 2025-07-27 09:30:26 发布
最新推荐文章于 2025-07-27 09:30:26 发布
阅读量341 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构算法 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zhengfushijie/article/details/39754519

1 没有头节点的单链表操作

实验证明：在某些情况下(比如拷贝构造函数，尾插法建表)，不带头结点的单链表需要单独处理第一个元素。引入头结点的好处在于表中的每个元素的处理可以统一。

<pre name="code" class="cpp">// LinkList.cpp : 定义控制台应用程序的入口点。
//定义的链表不含头结点


#include <iostream>
using namespace std;

template<class Type>
//定义结点
struct Node
{
	Type data;
	Node<Type> *next;
};
//定义链表
template<class Type>
class LinkList
{
public:
	LinkList();//默认构造函数
	LinkList(const LinkList<Type>& otherList);//拷贝构造函数
	~LinkList();
	void createInsertHead();//头插法
	void createInsertRear();//尾插法
	void initList();//将链表归为初始状态
	bool isEmpty();//判断链表是否为空
	int  length();
	void destoryList();//销毁链表
	void getFirstData(Type& firstdata);
	void getData(int pos,Type& data);
	void insertFirst(Type newdata);//在表头插入新的元素
	void insertLast(Type newdata);//在表尾插入新的元素
	void deleteFirst(Type& data);//删除表头元素
	void deleteLast(Type& data);//删除表尾元素
	void reverse();
	void del_x(Type& data);    //删除所有值为data的结点
	const LinkList<Type>& operator=(const LinkList<Type>&otherList);//重载赋值运算符
	friend ostream& operator<< <>(ostream& cout,const LinkList<Type>& list);
private:
	int m_length;//链表中结点个数
	Node<Type>* head; //不使用头结点
};

template<class Type>
LinkList<Type>::LinkList()//默认构造函数
{
	//head = new Node<Type>;
	head = NULL;
	m_length = 0;
}

template<class Type>
LinkList<Type>::LinkList(const LinkList<Type>& otherList)//拷贝构造函数
{	
	head = NULL;
	m_length = otherList.m_length;
	
	Node<Type> *current;
	Node<Type> *otherListcurrent = otherList.head;
	while(otherListcurrent != NULL)
	{
		for (int i=1; i<=otherList.m_length; i++)
		{
			Node<Type> *newnode = new Node<Type>;
			newnode->data = otherListcurrent->data;
			newnode->next = NULL;

			if (i == 1)
			{
				head = newnode;
				current = head;
			}
			else
			{
				current->next = newnode;				
				current = current->next;				
			}
			otherListcurrent = otherListcurrent->next;
		}       
	}
}

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

template<class Type>
void LinkList<Type>::createInsertHead()//头插法
{
	Node<Type> *newnode;
	cout<<"请输入链表的长度：";
	cin>>m_length;
	cout<<"请输入链表的元素：";
	for (int i=0; i<m_length; i++)
	{
	   newnode = new Node<Type>;
       cin>>newnode->data;
	   newnode->next = head;
	   head = newnode;
	}
}

template<class Type>
void LinkList<Type>::createInsertRear()//尾插法    尾插法和拷贝构造函数都有单独考虑第一个结点的情况
{
	Node<Type> *newnode;
	Node<Type> *current;
	cout<<"请输入链表的长度：";
	cin>>m_length;
	cout<<"请输入链表的元素：";
	for (int i=1; i<=m_length; i++)
	{
		newnode = new Node<Type>;
		cin>>newnode->data;
        newnode->next = NULL;
		if (i==1)
		{
			head = newnode;
			current = head;
		}
		else
		{
			current->next = newnode;
			current = current->next;
		}
	}
}

template<class Type>
void LinkList<Type>::initList()
{
	destoryList();
	head = NULL;
	m_length = 0;
}

template<class Type>
bool LinkList<Type>::isEmpty()
{
	if (head == NULL)
	{
		return true;
	}
	else 
	{
		return false;
	}
}

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

template<class Type>
void LinkList<Type>::destoryList()
{
	Node<Type> *current;
	while(head != NULL)
	{
		current = head;
		head = current->next;
		delete current;			
	}
	head = NULL;
	m_length = 0;
}

template<class Type>
void LinkList<Type>::getFirstData(Type& firstdata)
{
	if (head!=NULL)
	{
		firstdata = head->data;
	}
	else 
	{	
		cout<<"链表为空！"<<endl;
	}
}

template<class Type>
void LinkList<Type>::getData(int pos,Type& data)
{
   if (pos<1||pos>m_length)
   {
	   cout<<"指定的位置不正确！"<<endl;
   }
   else
   {
	   Node<Type> *current = head;
	   int i=0;
	   while(i<pos-1)
	   {
		   current = current->next;
		   i++;
	   }
	   data = current->data;
   } 
}

template<class Type>
void LinkList<Type>::insertFirst(Type newdata)
{
	Node<Type> *newnode = new Node<Type>;
	newnode->data = newdata;
	newnode->next = head;
	head = newnode;
	m_length++;
}

template<class Type>
void LinkList<Type>::insertLast(Type newdata)//尾部插入元素
{
	Node<Type> *current = head;
	while(current != NULL && current->next != NULL)
	{
		current = current->next;
	}
	Node<Type> *newnode = new Node<Type>;
	newnode->data = newdata;
	if (current==NULL)
	{
		/*newnode->next = current;
		current = newnode;*/
		newnode->next = head;
		head = newnode;
	}
	else
	{
		newnode->next = current->next;
		current->next = newnode;
	}	
	m_length++;
}

template<class Type>
void LinkList<Type>::deleteFirst(Type& data)
{
	if (isEmpty())
	{
		cout<<"链表为空！"<<endl;
	}
	else
	{
		if(m_length==1)
		{
			Node<Type> *temp = head;
			data = head->data;
			delete temp;
			head=NULL;
		}
		else
		{
			Node<Type> *temp = head;
			data = head->data;
			head = head->next;
			delete temp;
		}
		m_length--;
	}
}

template<class Type>
void LinkList<Type>::deleteLast(Type& data)
{
	if (isEmpty())
	{
		cout<<"链表为空！"<<endl;
	}
	else
	{
		if(m_length==1)
		{
			Node<Type> *current = head;
			data=current->data;
			delete(current);
			m_length--;
			head=NULL;
		}
		else
		{
			Node<Type> *current = head;
			for (int i=1; i<m_length-1; i++)
			{
				current = current->next;
			}
			Node<Type> *temp = current->next;
			data = temp->data;
			current->next = temp->next;
			delete temp;
			m_length--;
		}
		
	}	
}

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

template<class Type>
void LinkList<Type>::del_x(Type& data)
{
	Node<Type> *current = head;
	Node<Type> *current1 = head;
	if (current == NULL)
	{
		cout<<"链表为空！"<<endl;
	}
	else
	{
		while(current->next!=NULL)
		{
			if(current->data==data)
			{
				Node<Type> *tmp=current->next;
				current->data=current->next->data;
				current->next=current->next->next;
				delete(tmp);
				m_length--;
			}
			else
			{
				current=current->next;
			}
		}
		if(current->data==data)
		{
		   if(m_length==1)
		   {
			   head=NULL;
			   m_length=0;
		   }
		   else
		   {
			   while(current1->next->next!=NULL)
				   current1=current1->next;
			   current1->next=NULL;
			   delete(current);
		   }
		}
	}
}

template<class Type>
const LinkList<Type>& LinkList<Type>::operator=(const LinkList<Type>&otherList)
{
	Node<Type> *current;
	Node<Type> *otherListcurrent = otherList.head;
	if (this!=&otherList)
	{
		if (!isEmpty())
		{
			initList();			
		}
		if (otherListcurrent!=NULL)
		{			
			for (int i=1; i<=otherList.m_length; i++) //或用while
			{
				Node<Type> *newnode = new Node<Type>;
				newnode->data = otherListcurrent->data;
				newnode->next = NULL;
				if (i==1)
				{
					head = newnode;
					current = head;//current始终指向链表的尾元素
				}
				else
				{
					current->next = newnode;
					current = current->next;
				}
				otherListcurrent = otherListcurrent->next;
			}
		}
	}
	return *this;
}

template<class Type>
ostream& operator<< <>(ostream& cout,const LinkList<Type>& list)
{
	Node<Type> *current = list.head;
	if (current==NULL)
	{
		cout<<"链表为空！"<<endl;
	}
	else
	{			
		while(current!=NULL)
		{
			cout<<current->data<<" ";
			current = current->next;
		}
		cout<<endl;
	}
	return cout;
}




int main(int argc, char* argv[])
{
	char a='a';
    LinkList<char> *list = new LinkList<char>;
	list->createInsertRear();
	cout<<"list:"<<*list;
	list->deleteLast(a);
	cout<<"list:"<<*list;
	system("pause");
	return 0;
}





2 带头节点的单链表




//单链表的初始化，建立，插入，查找，删除。//
//////////////////////////////////////////// 
#include <iostream>
using namespace std;
//////////////////////////////////////////// 
//定义结点类型
template<class Type>
struct Node
{
	Type data;				            //单链表中的数据域 
	struct Node<Type> *next;			//单链表的指针域 
};



template<class Type>
class  LinkList
{
public:	
	LinkList();//默认构造函数
	void LinkedListCreatF(); //单链表的建立1，头插法建立单链表
	void LinkedListCreatR(); //单链表的建立2，尾插法建立单链表
	void LinkedListInsert(int i,Type x);//单链表的插入，在链表的第i个位置插入x的元素
	void LinkedListDelete(Type x);//单链表的删除，在链表中删除值为x的元素
	const LinkList<Type>& operator=(const LinkList<Type>&otherList);//重载赋值运算符  
	friend ostream& operator<< <>(ostream& cout,const LinkList<Type>& list);  
private:  
	int m_length;//链表中结点个数  
	Node<Type> *head; //带头结点  
};

template<class Type>  
LinkList<Type>::LinkList()//默认构造函数  
{  
	head = new Node<Type>;
	head->next = NULL;  
	m_length = 0;  
}  


//单链表的建立1:头插法建立单链表
template<class Type>
void LinkList<Type>::LinkedListCreatF()
{
	Type x;							//x为链表数据域中的数据
	cout<<"输入链表数据："<<endl;
	while(cin>>x)
	{
		Node<Type> *p=new Node<Type>;	//申请新的结点 
		p->data = x;//结点数据域赋值
		p->next=head->next;
		head->next=p;					//将结点插入到表头L-->|2|-->|1|-->NULL 
	}
} 

//单链表的建立2:尾插法建立单链表
template<class Type>
void LinkList<Type>::LinkedListCreatR()
{
	Node<Type> *r=head;					//r始终指向终端结点，开始时指向头结点 
	Type x;							//x为链表数据域中的数据
	cout<<"输入链表数据："<<endl;
	while(cin>>x)
	{
		Node<Type> *p=new Node<Type>;	//申请新的结点 
		p->data = x;					//结点数据域赋值 
		r->next = p;					//将结点插入到表头L-->|1|-->|2|-->NULL 
		r = p; 
	}
	r->next = NULL; 
}

//单链表的插入，在链表的第i个位置插入x的元素
template<class Type>
void LinkList<Type>::LinkedListInsert(int i,Type x)
{
	Node<Type> *pre;						//pre为前驱结点 
	pre = L;
	int tempi = 0;
	for (tempi = 1; tempi < i; tempi++)
		pre = pre->next;					//查找第i个位置的前驱结点 
	Node<Type> *p=new Node<Type>;			//插入的结点为p
	p->data = x; 
	p->next = pre->next;
	pre->next = p;					 	
} 

//单链表的删除，在链表中删除值为x的元素
template<class Type>
void LinkList<Type>::LinkedListDelete(Type x)
{
	Node<Type> *p,*pre;					//pre为前驱结点，p为查找的结点。 
	p = L->next;
	while(p->data != x)				//查找值为x的元素 
	{	
		pre = p; 
		p = p->next;
	}
	pre->next = p->next;			//删除操作，将其前驱next指向其后继。 
	free(p);
} 

template<class Type>  
const LinkList<Type>& LinkList<Type>::operator=(const LinkList<Type>&otherList)  
{  
	Node<Type> *current;  
	Node<Type> *otherListcurrent = otherList.head->next;  
	if (this!=&otherList)  
	{  
		if (!isEmpty())  
		{  
			initList();           
		}  
		if (otherListcurrent!=NULL)  
		{             
			for (int i=1; i<=otherList.m_length; i++) //或用while  
			{  
				Node<Type> *newnode = new Node<Type>;  
				newnode->data = otherListcurrent->data;  
				newnode->next = NULL;  
				if (i==1)  
				{  
					head = newnode;  
					current = head;//current始终指向链表的尾元素  
				}  
				else  
				{  
					current->next = newnode;  
					current = current->next;  
				}  
				otherListcurrent = otherListcurrent->next;  
			}  
		}  
	}  
	return *this;  
}  

template<class Type>  
ostream& operator<< <>(ostream& cout,const LinkList<Type>& list)  
{  
	Node<Type> *current = list.head->next;  
	if (current==NULL)  
	{  
		cout<<"链表为空！"<<endl;  
	}  
	else  
	{             
		while(current!=NULL)  
		{  
			cout<<current->data<<" ";  
			current = current->next;  
		}  
		cout<<endl;  
	}  
	return cout;  
}  


int main(int argc, char* argv[])
{
	LinkList<int> *list = new LinkList<int>;
	list->LinkedListCreatR();
	cout<<"list:"<<*list;
	system("pause");
	return 0;
} 















                

        

    

    
  



    



                



	

		

			

				
					
单链表插入

				
			

			

				

					Python、C++、HTML、Java
				

				

					09-23
					
					1049
					
				

			

		

		

			
				
【问题描述】
设有头结点单链表，实现单链表插入算法。
【输入形式】
第一行输入一个N（N大于等于1，小于1000）；
第二行输入N个整数，以空格作为分隔，创建长度为N的单链表；
第三行输入pos和e，以空格分隔，分别表示插入位置和插入元素的值。
【输出形式】
若插入成功，输出插入元素后的单链表；若插入不成功，输出error。

			
		

	



                

            
              



	

		

			

				
					
C语言—单链表

				
			

			

				

					2302_81120572的博客
				

				

					10-06
					
					3913
					
				

			

		

		

			
				
C语言—单链表

			
		

	



              


  
              

                


	

		

			

				
					
数据结构-单链表基本操作-C语言代码

					
热门推荐

				
			

			

				

					suxiaorui的博客
				

				

					01-22
					
					6万+
					
				

			

		

		

			
				
单链表基本操作
1.头插法建立单链表
2.尾插法建立单链表
3.查找结点
3.修改结点
4.插入结点
5.删除结点
本篇只有c语言代码，具体思路讲解请看这篇博客：数据结构-线性结构-单链表
1.头插法建立单链表
#include<stdio.h>
#include<stdlib.h>

//单链表的结构定义 
typedef struct LNode
{
	int data...

			
		

	





	

		

			

				
					
建立单链表

				
			

			

				

					Dream_begin_的博客
				

				

					01-11
					
					5753
					
				

			

		

		

			
				
链表是动态地进行存储分配的一种结构，链表中的数据在内存中不必连续存放，数据之间通过指针链接起来，相比于数组结构，链表的插入和删除操作比较方便。单链表的建立链表：通过自引用结构的指针域，将各结点相互连接。关于链表的基本概念：

(1)链表的第一个结点称头指针或头结点，它指向链表在内存中的首地址，

(2)其后的结点是通过结点中的链节指针成员访问的。

(3)链表的最后一个结点称为尾节点。尾节点的指针域通常被设置成NULL。

(4)链表中的每一个结点是在需要的时候建立的。

(5)各结点在内存中的存储地址不一

			
		

	



		

			
		



	

		

			

				
					
C语言单链表

				
			

			

				

					knighthood2001
				

				

					05-06
					
					2267
					
				

			

		

		

			
				
int data;} Node;这里我们使用typedef将struct Node命名为Node。当然很多书以及代码中会使用到如下的int data;这里它还定义了一个指向这个结点的指针，当然对于初学者（笔者也是初学者）来说。使用*LinkList后，不太好理解，这里笔者就使用上述Node的版本。

			
		

	





	

		

			

				
					
单链表简单实现

				
			

			

				

					南猿北者博客
				

				

					10-31
					
					2525
					
				

			

		

		

			
				
单链表逻辑图：单链表同顺序表一样，都是线性表，除了首尾节点之外，任何一个节点都有自己的前驱和后继；但是单链表每个节点在物理上的地址是不连续的或者说是随机的，也就是说单链表的节点是要一个就开一个，不会过多的开辟空间；这一点正是弥补了顺序表的不足；从上面的逻辑图我们就可以看出，每个节点的类型应该是一样的，节点主要分为数据域和指针域，同时对于一串链表来所，最后一个节点的指针域一定是NULL，以此来标记这是链表的结尾；同时我们只需要知道单链表的头节点，就可以很好的管理整个链表；

			
		

	





	

		

			

				
					
C++单链表逆序

				
			

			

				

					m0_51380378的博客
				

				

					07-12
					
					1104
					
				

			

		

		

			
				
牛客网真题：单链表的逆序
C++的单链表逆序：
创建3个指针，分别指向当前头节点位置，空空。
先将一个指针指向头节点的下一个节点，下一个节点为当前节点的下一个节点，当前节点的下一个节点为前一个节点，前一个结点为当前节点，当前节点为下一个节点。
	struct ListNode* ReverseList(struct ListNode* pHead ) {
    // write code here
        struct ListNode *pre = NULL;
        struct Li

			
		

	





	

		

			

				
					
数据结构————单链表

				
			

			

				

					m0_66847953的博客
				

				

					09-09
					
					7439
					
				

			

		

		

			
				
单链表（Singly Linked List）是一种基本的数据结构，它由一系列节点组成，每个节点包含两部分：数据域和指针域。数据域用于存储实际的数据，而指针域则存储指向链表中下一个节点的地址。在单链表中，除了最后一个节点外，每个节点的指针域都指向下一个节点，最后一个节点的指针域通常设置为NULL，以标识链表的结束。单链表的特点是其存储不需要连续的内存空间，节点可以分散在内存中的任意位置，通过指针连接形成线性结构。头插法指的是在单链表的头部插入节点。新节点的指针将指向当前的头节点，然后更新头指针以指向新节点。

			
		

	





	

		

			

				
					
关于单链表

				
			

			

				

					优快云_YJX的博客
				

				

					04-07
					
					191
					
				

			

		

		

			
				
基础知识：什么是单链表，链式存储结构详解
单链表
基础操作：单链表的基本操作（C语言版）
最后附加一篇大佬的文章  【C语言】链表及单链表基本操作



			
		

	





	

		

			

				
					
单链表-实验报告.doc

				
			

			

				

					03-10
				

			

		

		

			
				
在计算机科学与技术领域，单链表是一种重要的基础数据结构，它由一系列节点组成，每个节点包含数据域和指针域，其中指针域指向下一个节点。单链表的节点之间通过指针连接，形成一条单向的线性结构。单链表的特点是...

			
		

	





	

		

			

				
					
数据结构-单链表-实验报告.rar_C++_tripk8z_单链表_单链表实验_实验报告

				
			

			

				

					09-21
				

			

		

		

			
				
（2）验证单链表及其基本操作的实现； （3）进一步理解算法与程序的关系，能够将单链表算法转换为对应的程序。 1.2 实验要求： （1）用头插法（或尾插法）建立带头结点的单链表； （2）对已建立的单链表实现插入、...

			
		

	





	

		

			

				
					
使用C++实现单链表的基本操作：1、创建单链表2、遍历单链表3、单链表插入4、删除单链表5、判断是否为空6、单链表的

				
			

			

				

					03-27
				

			

		

		

			
				
本文将详细阐述如何使用C++来实现单链表的基本操作，包括创建、遍历、插入、删除、判断空、计算长度以及查找节点。  首先，我们从创建单链表开始。单链表是由一系列节点组成的数据结构，每个节点包含一个数据元素和...

			
		

	





	

		

			

				
					
头歌数据结构单链表的基本操作

				
			

			

				

					05-18
				

			

		

		

			
				
头歌数据结构单链表的基本操作 第1关单链表的插入操作 第2关单链表的删除操作 第3关单链表的按照序号查找值操作 第4关单链表的按照值查找结点位序的操作 第5关单链表的逆置操作 第6关两个有序单链表的合并操作 稳过 ...

			
		

	





	

		

			

				
					
c++--面向对象封装--实践

				
			

			

				

					weixin_63164319的博客
				

				

					07-23
					
					1139
					
				

			

		

		

			
				
单参构造函数：参数为 const char*，支持隐式类型转换（如 mystring str = "hello";列表初始化：len(strlen(s)) 在对象构造前初始化 len，比在函数体中赋值更高效。// 输出：你好world你好。计算新长度 len + other.len（或 len + strlen(s)）。// 复制 "world"str.append(ptr);// 追加 "world"str.copy("你好");// 复制 "你好"str.append("你好");// 追加 "你好"

			
		

	





	

		

			

				
					
C语言：函数变量作用域、指针入门

				
			

			

				

					2301_77829391的博客
				

				

					07-27
					
					590
					
				

			

		

		

			
				
*概念：**变量在程序运行中的存在时间（内存申请到内存释放的时间）根据变量存在的时间不同，变量可分为静态存储方式和动态存储方式//写法1 数据类型 * 变量列表;//写法2 数据类型 * 变量列表;//普通变量int a;//指针变量int *p1;// 正确//正确int* p4;//正确int* p5,p6;//注意：p6被当作int变量，不是指针注意：指针变量的值只能是8（32位系统）|  12（64位系统）位的十六进制整数。① 虽然定义指针变量*a，是在变量名前加上。

			
		

	





	

		

			

				
					
C语言（十）

				
			

			

				

					2302_80202237的博客
				

				

					07-24
					
					414
					
				

			

		

		

			
				
函数是面向过程编程思想的具体体现，主要作用：降低程序之间的耦合性提高代码的复用性和可维护性一个完整的 C 程序由**一个或多个程序模块（源文件）**组成。为便于开发与调试，通常会将代码拆分为多个源文件，并组合成一个整体程序。每个源文件是一个编译单位，即 C 编译器以“源文件”为单位进行编译。程序从main()函数开始执行，调用其他函数后，执行完再返回到main()，最终在main()结束程序运行。用户根据需要自定义提高模块化和代码复用能力。

			
		

	





	

		

			

				
					
《C++ list 完全指南：list的模拟实现》

					
最新发布

				
			

			

				

					铭哥不写bug的博客
				

				

					07-27
					
					692
					
				

			

		

		

			
				
本文介绍了C++ list 完全指南中0list的模拟实现，期待你的关注！

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值