C++实现单链表

最新推荐文章于 2024-05-16 21:12:43 发布
最新推荐文章于 2024-05-16 21:12:43 发布
阅读量248 收藏
点赞数
分类专栏： C/C++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iynu17/article/details/51588213
版权

单链表的结构有多种

这里介绍的链表有头结点、有尾节点并且尾节点指向头结点

wKioL1btPpKSlsBmAAAKFtUh58k849.png

SList.h

//****************/

typedef int DataType;

//节点类（复合形态）
//struct LinkNode     
//{
//	friend class SList;      //将SList设为友元，便于SList类可以访问节点类的私有成员
//public:
//	LinkNode(const DataType x);	
//private:
//	DataType _data;    //节点的数据
//	LinkNode* _next;    //指向该节点的下一个节点
//};

//直接用struct定义LinkNode类，因为struct的成员默认为公有数据成员，所以可直接访问
struct LinkNode      //节点类(建议写法)
{
	LinkNode(const DataType x);
	DataType _data;    //节点的数据
	LinkNode* _next;    //指向该节点的下一个节点
};
class SList
{
public:
	SList();         //构造函数
	SList(const SList& s);        //拷贝构造
	SList &operator=(SList& s);    //赋值运算符的重载
	~SList();

public:   
        //单链表的具体操作
        void Uniqe();         //去重
	void Merge(SList &s);  //合并
	void Sort();       //冒泡
	void Reverse();   //翻转
	void Swap(SList& s);      //交换
	void PrintSList();   //打印链表
	void PushBack(const DataType& x);    //在尾部插入一个节点
	void Clear();         //链表置空
	void PopBack();       //删除尾节点
	void PushFront(DataType x);  //头插
	void PopFront();    //删除首节点
	void Insert(LinkNode* pos, DataType x);//固定位置插入一个节点
	void Erase(LinkNode* pos);        //删除某一节点
	LinkNode* Find(DataType x);       //查找节点并返回这个节点的地址
	int Amount();   //计算链表节点的数目
	void Remove(DataType x);     //查找某节点并删除
	void RemoveAll(DataType x);      //删除链表中所有的x
	
private:	
	LinkNode* _head;     //指向头节点
	LinkNode* _tail;        //指向尾节点
};
//*********************//

SList.cpp   (函数实现)

//**********************/
#include<iostream>
using namespace std;
#include<assert.h>
#include"SList.h"

   LinkNode::LinkNode(const DataType x)
           :_data(x)
           , _next(NULL)
           {}

    SList::SList()         //构造函数
		:_head(NULL)
		, _tail(NULL)
	{}
	SList::SList(const SList& s)          //拷贝构造
		:_head(NULL)
		, _tail(NULL)
	{
		if (s._head == NULL)
		{
			return;
		}
		LinkNode* tmp = s._head;
		do{
			PushBack(tmp->_data);
			tmp = tmp->_next;
		    } while (tmp != s._head);
		
	}
    //赋值运算符的重载（传统方法）
	//SList & SList::operator=(const SList& s)    
	//{
	//	if (this != &s)
	//	{
	//		_head = NULL;
	//		_tail = NULL;
	//		LinkNode* tmp = s._head;
	//	do{
	//		PushBack(tmp->_data);
	//		tmp = tmp->_next;
	//	     } while (tmp != s._head);
	//	}
	//	return *this;	
	//}
    
	//赋值运算符的重载（高效写法）
	/*void SList::Swap(SList& s)     
	{
	swap(_head, s._head);
	swap(_tail, s._tail);

	}
	SList&  SList::operator=(SList &s)
	{
	if (this != &s)
	{
	SList tmp(s);
	Swap(tmp);
	}
	return *this;
	}*/

	SList&  SList::operator=(SList &s)     //赋值运算符的重载再优化(推荐写法)
	{
		if (this != &s)
		{
			swap(_head, s._head);
			swap(_tail, s._tail);
		}
		return *this;
	}
	SList::~SList()    //析构
	{
		Clear();
	}
        
        void SList::Reverse()   //链表逆置（利用头插新节点的方法）
	{
		if (_head == NULL||_head->_next==_tail)
		{
			return;
		}
		int ret = Amount();
		_tail = new LinkNode(_head->_data);
		LinkNode* begin=NULL;
		LinkNode* tmp = _tail;
		while (--ret)
		{
			LinkNode* del = _head;
			_head = _head->_next;
			delete del;	//这里不要忘记做清理工作，否则内存泄漏
			begin = new LinkNode(_head->_data);
			begin->_next = tmp;
			_tail->_next = begin;
		    tmp = begin;
		}
		_head = begin;
	}  

        //打印链表
	void SList::PrintSList()  
	{
		//头结点为空时，无需打印链表
		if (_head==NULL)
		{
			cout << "This SList is Empty !" << endl;
			return;
		}
		else
		{
			LinkNode* tmp = _head;
			do{ 
				cout << tmp->_data << "-->";
				tmp = tmp->_next;
			    } while (tmp != _head);
			cout << endl;
		}
	}
	void SList::PushBack(const DataType& x)    //在尾部插入一个节点
	{
		//如果链表为空，插入节点后只有一个节点，此时_head=_tail
		if (_head == NULL)
		{
			_head = new LinkNode(x);
			_tail = _head;
			_tail->_next = _head;
		}
		else
		{
			_tail->_next = new LinkNode(x);
			_tail = _tail->_next;
			_tail->_next = _head;
		}
	}
	void SList::Clear()         //链表置空
	{
		LinkNode* begin = _head;
		while (begin != _tail)
		{
			_head = _head->_next;
			delete begin;
			begin = _head;
		}
		_head = NULL;
		_tail = NULL;
	}
	void SList::PopBack()    //尾删
	{
		if (_head == NULL)
		{
			cout << "This SList is empty !" << endl;
		}
		else if (_head == _tail)
		{
			delete _head;
			_head = NULL;
			_tail = NULL;
		}
		else
		{
			LinkNode* cur = _head;
			while (cur->_next != _tail)
			{
				cur = cur->_next;
			}
			delete _tail;
			_tail = cur;
			_tail->_next = _head;
	     }
	}
	void SList::PushFront(DataType x)  //头插
	{
		if (_head == NULL)
		{
			PushBack(x);
		}
		else
		{
			LinkNode* tmp = _head;
			_head = new LinkNode(x);
			_head->_next = tmp;
			_tail->_next = _head;
		}
	}
	void SList::PopFront()    //删除首节点
	{
		if (_head == NULL)
		{
			cout << "This SList is empty !" << endl;
			return;
		}
		LinkNode* tmp = _head;
		_head = _head->_next;
		_tail->_next = _head;
		delete tmp;
	}

	//固定位置插入一个节点（这个函数需和Find函数搭配使用）
	//先用Find函数找到新节点需要插入的位置
	//（将Find函数的返回值传给Insert函数的参数pos）,再在pos节点后面插入新节点x
	void SList::Insert(LinkNode* pos, DataType x)
	{
		assert(pos);
		if (pos==_tail)
		{
			PushBack(x);
		}
		else
		{
			LinkNode* tmp = new LinkNode(x);
			tmp->_next = pos->_next;
			pos->_next = tmp;
		}
	}
	
        //删除某一节点，同样，要先找到该节点并传参给Erase函数
	void SList::Erase(LinkNode* pos)        
	{
		assert(pos);
		if (pos == _tail)
		{
			PopBack();
		}
		if (pos == _head)
		{
			PopFront();
		}
		else
		{
			LinkNode* prev = _head;
			while (prev->_next != pos)
			{
				prev = prev->_next;
			}
			prev->_next = pos->_next;
			delete pos;
		}
	}
	LinkNode* SList::Find(DataType x)       //查找节点并返回这个节点的地址
	{
		if (_head == NULL)
		{
			cout << "This SList is empty !" << endl;
			return NULL;
		}
		else
		{
			LinkNode* tmp = _head;
			do{
					if (tmp->_data == x)
					{
						return tmp;
					}
						tmp = tmp->_next;
			} while (tmp != _head);
			return NULL;
		}
	}
	int SList::Amount()   //计算链表节点的数目
	{
		if (_head == NULL)
		{
			return 0;
		}
		else
		{
			int count = 0;
			LinkNode* cur = _head;
			while (cur != _tail)
			{
				count++;
				cur = cur->_next;
			}
			return ++count;
		}
	}
	void SList::Remove(DataType x)      //查找某节点并删除
	{
		if (_head == NULL)
		{
			cout << "This SList is empty !" << endl;
		}
		else
		{
			LinkNode* tmp = Find(x);
			if (tmp != NULL)
			{
				Erase(tmp);
			}
		}
	}
	void SList::RemoveAll(DataType x)       //删除链表中所有的x
	{
		if (_head == NULL)
		{
			cout << "This SList is empty !" << endl;
			return;
		}
//如果链表不为空，设置left和right前后指针，从头至尾遍历一遍，delete节点的data为x的节点

			LinkNode* left = _tail;
			LinkNode* right = _head;
			int count = Amount();
			while (count--)
			{
			 //当要删掉的节点是头节点时，需要注意头节点要指向它的下一个节点
			 //当要删掉的节点是尾节点时，需要注意尾节点要指向它的上一个节点
			 //当left和right指向同一块要删掉的节点时，将链表置空
			 
				if (right->_data == x)
				{
					if (_head == right)   
					{
						_head = _head->_next;
					}
					if (_tail == right)   
					{
						_tail =left;
					}
					if (right == left)    
					{
						_head = NULL;
						_tail = NULL;
						return;
					}
					LinkNode* tmp = right;
					right = right->_next;
					delete tmp;
					left->_next = right;
				}
				else
				{
					left = right;
					right = right->_next;
				}
			}	
	}
	void SList::Uniqe()       //去重(针对有序链表)
	{
		assert(_head &&_head!= _tail);
		LinkNode* left = _head;
		LinkNode* right = _head->_next;
		while (left != _tail)
		{
			while(left->_data == right->_data)
			{
				LinkNode* tmp = right;
				right = right->_next;
				left->_next = right;
				delete tmp;
			}
			left = left->_next;
			right = right->_next;
		}
	}
	void SList::Merge(SList &s)    //合并（针对有序链表）,合并后依然有序
	{
		//  1. _head为空
		//  2. 链表s为空
		if (_head == NULL)
		{
			_head = s._head;
			_tail = s._tail;
		}
		if (s._head == NULL)
		{
			return;
		}
		//  3. 两个链表都不为空
		LinkNode* phead = _head;
		if (phead->_data <= s._head->_data)
		{
			phead = phead->_next;
		}
		else
		{
			_head = s._head;
			s._head = s._head->_next;
		}
		LinkNode* cur = _head;
		while (1)
		{
			if (phead->_data <= s._head->_data)
			{
				_head->_next = phead;
				_head = _head->_next;
				if (phead == _tail)
				{
					_head->_next = s._head;	
					_tail=s._tail;
					_tail->_next = cur;
					break;
				}
				phead = phead->_next;
			}
			else
			{
				_head->_next = s._head;
				_head = _head->_next;
				if (s._head ==s._tail)
				{
					_head->_next = phead;
					_tail->_next = cur;
					break;
				}
				s._head = s._head->_next;
			}
			
		}
		_head = cur;
	}
	void SList::Sort()                      //冒泡排序
	{
		assert(_head);
		if (_head == _tail)
		{
			return;
		}
		int size = Amount();
		for (int i = 0; i < size-1 ; i++)	
		{
			LinkNode* left = _head;
			LinkNode* right = _head->_next;
			for (int j = 0; j < size - i-1 ; j++)
			{				
				if (left->_data>right->_data)
				{
					swap(left->_data, right->_data);
				}
				right = right->_next;
				left = left->_next;
			}		
		}
	}
///************************

测试用例（Test.cpp）

#include"SList.h"
#include<stdlib.h>

void Test3()
{
	//排序 去重 合并
	cout << "list 1:" << endl;
	SList list1;
  /*list1.PushBack(2);
	list1.PushBack(3);
	list1.PushBack(2);
	list1.PushBack(2);
	list1.PushBack(1);
	list1.PrintSList();
	list1.Sort();
	list1.PrintSList();
  list1.Uniqe();
	list1.PrintSList();*/

	list1.PushBack(5);
	list1.PushBack(3);
	list1.PushBack(8);
	list1.PushBack(2);
	list1.PushBack(9);
	list1.PushBack(10);
	list1.PushBack(2);
	list1.PushBack(2);
	list1.PushBack(1);
	list1.PrintSList();
	list1.Sort();
	list1.PrintSList();
	
	cout << "list 2:" << endl;
	SList list2;
	list2.PushBack(1);
	list2.PushBack(6);
	list2.PushBack(4);
	list2.PushBack(0);
	list2.PushBack(7);
	list2.PrintSList();
	list2.Sort();
	list2.PrintSList();

	cout << "list 1:" << endl<<endl;
	list1.Merge(list2);
	list1.PrintSList();
}
void Test2()
{
	SList list1;
	list1.PushBack(1);
	list1.PushBack(3);
	list1.PushBack(4);
	list1.PushBack(2);
	list1.PushBack(6);
	list1.PrintSList();

	/*list1.RemoveAll(2);
	list1.PrintSList();*/

	SList list2 = list1;
	/*list2.PushBack(2);
	list2.PushBack(3);
	list2.PushBack(4);
	list2.PushBack(2);
	list2.PushBack(2);*/
	list2.PrintSList();
	list2.Reverse();
	list2.PrintSList();
	
}
void Test1()
{
	//SList list1;
	//list1.PushBack(1);
	//list1.PushBack(2);
	//list1.PushBack(3);
	//list1.PushBack(4);
	//list1.PushBack(5);
	//list1.PrintSList();

	//list1.Remove(2);
	//list1.PrintSList();

	//int num =list1.Amount();
	//cout <<"节点个数："<< num << endl;

	/*//检验Erase函数
	LinkNode* del = list1.Find(2);
	list1.Erase(del);
	list1.PrintSList();
	*/

	/*//找到某节点并在其后插入新节点
	LinkNode* In =list1.Find(5);
	list1.Insert(In, 0);
	list1.PrintSList();*/

	/* //删除头结点
	list1.PopFront();
	list1.PrintSList();
	*//

	/*//查找节点
	LinkNode* ret=list1.Find(5);
	if (ret != NULL)
	{
	cout << "要查找的节点data是：" << ret->_data << endl;
	cout << "要查找的节点adress是：" <<ret<< endl;
	}
	else
	{
	cout << "not exit !" << endl;
	}*

	//验证构造函数
	//SList list2(list1);
	//list2.PrintSList();

	//验证赋值运算符的重载
	//SList list3 = list2;
	//list3.PrintSList();

	//验证析构函数
	//list3.Clear();
	//list3.PrintSList();

	//验证尾删和头插
	///*list3.PopBack();
	//list3.PrintSList();*/
	//list3.PushFront(0);
	//list3.PrintSList();
}

int main()
{
	//Test1();
	Test2();
	system("pause");
}


本文出自 “言安阳” 博客，谢绝转载！

Lynn-Zhang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 实现单链表
Risingstar
04-23 456
#include <iostream> using namespace std; // 单链表的实现 template<typename _Ty> class SingleList { public: SingleList(); ~SingleList(); private: typedef struct tagNode // 节点定义 { _Ty _...
C++ 单链表实现
WM_Kt的博客
10-26 306
链表定义 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 单个结点构成 链表结构 代码实现 写给初学者的话：在学习之前，建议了解一下结构体，指针方面的知识 PS： 本篇只介绍单链...
数据结构-单链表(c++)超全超详细
Abieai的博客
11-26 7486
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、单链表是什么？二、单链表上基本操作的实现1.定义单链表2.单链表初始化3.头插法4.尾插法5.任意位置插入6.按位取值7.按值取位8.删除结点9.打印链表10.销毁链表三、完整代码(功能过多，建议注释一部分使用)总结 前言 顺序表可以随时存取表中的任意一个元素，它的存储位置可以用一个简单直观的公式表示，但插入和删除操作需要移动大量元素。链式存储线性表时，不需要使用地址的连续存储单元，即不要求逻辑上相邻元素在物理地址上也相邻
C++实现单链表【每一步详细深入讲解，代码清晰、简单、易懂】
weixin_55755506的博客
12-03 4658
例如：我们需要在伪头节点（不包含数据）和含有1的节点之间插入一个节点，发现，只需要改变dummy的指针和需要插入的指针即可。通过对插入和删除的讨论，我们了解到，插入调用find函数时，并不需要操作其返回值，所以，返回值具体是该元素的节点还是其前面的节点并没有影响；，而第一个节点的前一个节点是dummy，这也是为什么我们需要dummy这个伪头节点。，因此，删除操作时我们必须得到需要删除节点的前一个节点，因此。先将要添加的元素的指针指向dummy节点的后一个节点。将要添加节点的指针指向之前的下一个节点。
C++——单链表的详细讲解
最新发布
imaima666的博客
05-16 974
链表是一种数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的指针。链表中的节点可以在内存中不连续地存储，通过指针来连接彼此。链表可以是单向链表，双向链表或循环链表。链表的优点是可以动态地分配内存空间，插入和删除操作效率高，但查找操作效率较低。
单链表（C++）
weixin_63198483的博客
11-14 1171
数据结构与算法---单链表上的各项操作（C++）
C++实现单链表的16种基本操作
weixin_47373497的博客
10-29 2462
C++实现单链表的16种基本操作 链表初始化，头插法创建链表，尾插法创建链表，取值，查找（第i个节点的数据域或者数据域为某个特定值的节点），有顺序的合并两个链表，无顺序的合并两个链表，插入，删除，逆置链表，求链表的节点个数，删除数据域重复的节点，输出链表，判空，置空链表。 以下是我写的头文件的代码 #ifndef DANLIANBIAO_H #define DANLIANBIAO_H #endif #include<iostream> #include<stdio.h> #inclu
C++单链表
weixin_62313265的博客
12-13 5087
链表是一种常见的数据结构。它主要是利用动态内存分配、结合结构体并配合指针来实现的，能根据需要开辟和释放内存单元。
C++实现单链表的构造
08-19
C++实现单链表的构造 在计算机科学中，链表是一种非常重要的数据结构，它能够动态地分配和释放内存，从而提高程序的效率和灵活性。今天，我们将详细介绍C++实现单链表的构造，包括链表的定义、常用函数的实现、链表...
c++实现单链表
03-29
用c++实现单链表，单链表的每个结点的地址存放在其直接前驱结点的指针域中。其中第一个结点没有前驱结点，因此需要一个头指针指向第一个节点，便于我们对整个链表进行操作；这里的单链表的最后一个节点的指针域存放...
使用C++实现单链表的基本操作：1、创建单链表2、遍历单链表3、单链表插入4、删除单链表5、判断是否为空6、单链表的
03-27
以上就是C++实现单链表的基本操作。理解并熟练运用这些操作，对于学习更高级的数据结构和算法至关重要。通过练习，你可以更好地掌握C++中的动态内存管理以及指针操作，这些都是编程能力的重要组成部分。
C++实现单链表删除倒数第k个节点的方法
08-30
"C++实现单链表删除倒数第k个节点的方法" 在C++编程中，单链表是一种常用的数据结构，删除单链表中的倒数第k个节点是一种常见的操作。本文将详细介绍C++实现单链表删除倒数第k个节点的方法，并结合实例形式分析了...
C++数据结构---单链表
weixin_45196915的博客
09-08 1229
C++数据结构—单链表 基础知识 单链表是线性表的一种，是指用链式存储结构表示线性关系，使逻辑上相邻的元素在结构上也相邻。 线性关系是指除了首元元素和尾元元素，任何结点都只有一个一个前驱和一个后继，首元没有前驱尾元没有后继。 链式存储结构不同与顺序存储结构其存储空间不是一片连续的存储单元，每个空间除了存储数据信息，还要存储数据的逻辑关系。所以用一个结点来表示，每个结点包含数据域和指针域，数据域用于存储元素本身，指针域定义了一个指针，用于指向元素的下一个结点（指向后继），从而形成链式结构。 根据链表结点所含指
C++ 单链表
vivian_ll的博客
10-22 1674
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)，简单来说链表并不像数组那样将数组存储在一个连续的内存地址空间里，它们可以不是连续的因为他们每个节点保存着下一个节点的引用（地址），所以较之数组来说这是一个优势。 ...
数据结构——单链表基本操作实现 (c++)
weixin_74794504的博客
03-16 2568
单链表链式存储结构的特点是：用一组任意的存储单元存储线性表的数据元素（这里存储单元可以是连续的，也可以是不连续的），为了表示每个数据元素a与其直接后继数据元素之间的逻辑关系，除了存储信息本身外还要存储一个指示其直接后继的信息（地址）.这两部分信息组成数据元素a的存储映像称为结点，它包括两个域：存储信息的称为数据域，存储直接后继存储地址的域称为指针域，指针域中存储的信息称作指针或链。
数据结构01-单链表（C++）
wqdtbs的博客
08-23 645
单链表的定义以及概念与结构。
单链表（C++实现）
qq_39559641的博客
04-07 3940
一、实验要求 (1).尾插法创建单链表，打印创建结果。 (2).头插法创建单链表，打印创建结果。 (3).销毁单链表。 (4).求链表长度。 (5).求单链表中第i个元素（函数），若不存在，报错。 (6).在第i个结点前插入值为x的结点。 (7).链表中查找元素值为x的结点，成功返回结点指针，失败报错。 (8).删除单链表中第i个元素结点。 (9).在一个递增有序的单链表L中插...
C++实现单链表（Single Linked List）
weixin_42133358的博客
05-14 7892
C++实现单链表（Single Linked List） 语言这个东西不用真的会忘， 我记得前前后后C++的基本语法我也看了好几遍了，一直没有动手写过什么东西，所以一遍遍的看，一遍遍的忘… … 正好最近在看数据结构，想着自己用C++来实现一下，一方面是熟悉整个逻辑过程，加深对数据结构的理解，另一方面，也熟悉一下C++。 单链表是线性表的链式存储结构，同顺序存储结构（可以理解为C++中的数组）不同的是，单链表在插入和删除一个结点时，不需要移动大量的元素，但是单链表没有数组中索引的概念，所以在查询一个元素
C++实现单链表：结点描述与初始化
"这篇资源主要介绍了单链表的实现，特别是如何在C++中描述链表结点，并展示了单链表的初始化以及在链表头部插入元素的基本操作。" 单链表是一种线性数据结构，它由一系列节点组成，每个节点包含数据和一个指向下一...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值