数据结构01-单链表（C++）

最新推荐文章于 2024-05-16 21:12:43 发布
最新推荐文章于 2024-05-16 21:12:43 发布
阅读量644 收藏 2
点赞数 7
文章标签： 数据结构 c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wqdtbs/article/details/132445327
版权

单链表的定义以及概念与结构：

    单链表是一种常见的数据结构，用于存储一系列元素。它由一系列称为节点（node）的对象组成，每个节点包含两个部分：数据部分和指针部分。数据部分存储该节点表示的元素的值。指针部分则指向下一个节点，在单链表中，每个节点只有一个指针指向下一个节点，最后一个节点的指针指向空（NULL）。通过这种方式，节点之间形成了一个链式的关系，因此称为链表。在单链表中，只能通过从头节点（第一个节点）开始顺序遍历整个链表才能访问到各个节点。

   结构：

typedef struct node  //typedef是函数的重命名 
{
	int data;         //存储结点，包括 data域和 next域 
	struct node *next;
}LNode ,*LinkList;

单链表的特点：

     链式存储结构；动态性；顺序访问；插入和删除效率高；内存消耗。

单链表的初始化：

     当我们开始使用单链表时，首先要对单链表进行初始化，创建一个带头结点的单链表。带头节点的单链表指的是在链表的头部添加一个空节点，该节点不存储实际的数据，仅用作头节点的前一个节点，也称为哨兵节点或者虚拟节点

代码实现：

void InitList(LinkList &L)//建立带头结点的单链表 
{
	L=new LNode;
	L->next=NULL;
 }

单链表的建立：

       头插法：    

        单链表的头插法（Head Insertion）是指在链表的头部插入新的节点的一种操作方法。具体步骤如下：

  1. 创建一个新节点，将要插入的数据存储在该节点中。
  2. 将新节点的指针指向原来链表的头节点（即新节点的 next 指针指向原来的头节点）。
  3. 将链表的头节点指向新节点（即头指针指向新节点）。

 代码实现：

 //头插法建表   输入结果与输出结果相反 
void InputList_H(LinkList &L,int n)
 {
 	LNode *p;                            //用于专门开辟新的节点，用来插入节点                     
	cout<<"请输入这"<<n<<"个数：";                           
 	for(int i=1;i<=n;i++)
 	{
 		p=new LNode;                     //申请链表LNode的空间                         
 		cin>>p->data;
 		p->next = L->next;              //将新结点插入头节点后面
 		L->next = p;
	 }
}

        尾插法：

         单链表的尾插法（Tail Insertion）是指在链表的尾部插入新的节点的一种操作方法。具体步骤如下：

  1. 创建一个新节点，将要插入的数据存储在该节点中。
  2. 若链表为空，则将链表的头节点指向新节点（即头指针指向新节点），并将新节点作为尾节点。
  3. 若链表不为空，则找到当前链表的尾节点（即遍历到 next 指针为 null 的节点）。
  4. 将尾节点的 next 指针指向新节点，将新节点作为新的尾节点。

   

代码实现：

//尾插法建表  输入顺序与输出顺序一致 
void InputList_R(LinkList &L,int n)
{
	LNode *p;                         //用于专门开辟新的结点
	LNode *r;                         //用于指向表尾结点 
	r=L; 
	while(r->next!=NULL)              //先遍历链表在插入 
	{
		r=r->next;
	}
	cout<<"请输入这"<<n<<"个数：";
	for(int i=1;i<=n;i++)
	{
		p=new LNode;                  //申请链表LNode的空间
		cin>>p->data; 
		//将新结点插入表尾 
		r->next=p;
		r=p;        //将新插入的结点的指针p变为指针r，把插入的结点变为新的尾结点 
	}
	r->next=NULL;
}

单链表的遍历：

    代码思路：我们要遍历一个单链表。首先是要创建一个用于遍历节点的指针p，它最开始是指向表头下一个节点，然后输出该节点data域的数值，随后在 p=p->next，让p又指向当前节点的下一个节点，直到没有

   代码实现：

//链表遍历
void ShowList(LinkList &L) 
{
	LNode *p;   //用于专门开辟新的结点
	p=L->next;  //先将遍历指针指向头部，用头部往下进行遍历 
	cout<<"它的值如下："<<endl;
	while(p!=NULL)
	{
		cout<<p->data<<"\t";
		p=p->next; 
	 } 
}

单链表的长度：

代码思路：其实与单链表的遍历的思路是一致的，不过要多一个整数

代码实现：

//计算表长    通过遍历的方法进行计算表的长度 
void GetLength(LinkList &L)
{
	LNode *p;   //用于专门开辟新的结点
	p=L->next;  //先将遍历指针指向头部，用头部往下进行遍历
	int i=0;      //头结点不做计算   
	while(p!=NULL)
	{
		p=p->next;
		i=i+1; 
	 } 
	 cout<<"该表长是："<<i<<endl;
 }

单链表的按位查找：

查找链表中第n个位置的data值

代码思路：首先是要创建一个用于遍历节点的指针p，p指针用于指向第n个位置节点，所以我们要对链表进行依次遍历，直到p指向第n个位置，然后输出该节点下的数值

代码实现：

 //按位置进行查找
void ShowOne(LinkList &L,int n)
{
	LNode *p;            //用于专门开辟新的结点
	p=L->next;           //要向下进行遍历，所以该指针要先指向第一个（头结点的下一个） 
	for(int i=1;i<n;i++)
	{
		p=p->next;
	}
	cout<<"这个位置的值是："<<p->data<<endl;
 }

单链表的按位删除：

代码思路：首先是要创建一个用于遍历节点的指针p，另外创建一个指向被删除节点的指针q，当我们删除q指向的节点后，我们会发现链表已经断开，此时我们便要通过q节点以及p节点来恢复链表，删除前要想将p的下一个节点变成q的下一个节点也就是p->next=q->next。

代码实现：

 //按位置删除
 void DelList_W(LinkList &L,int n)
 {
 	LNode *p,*q;     //开辟两个新的指针，一个用于先遍历查找到要删除的结点， 
 	p=L;
 	for(int i=1;i<n;i++)
 	{
 		p=p->next;
	 }
	 q=p->next;                 //此时的q正指向要删除的的结点 
	 p->next=q->next;           //q指的是被删除的结点的前驱，删除q后，q后续的结点要向前 
	 delete(q);                 //删除q 
	 while(p->next!=NULL)       //将q后续的结点推向前 
	 {
	 	p=p->next;
	 }
  }

单链表的按位插入：

代码思路：首先也是创建两个指针，一个遍历p，另外一个用于创建一个新的节点q，当我们遍历到要插入的位置时，则我们需要先把q的next指向p的next，然后将p的next重新指向q。

代码实现：

void DelList_I(LinkList &L,int n)
 {
 	LNode *p,*q;     //开辟两个新的指针，一个用于遍历，查一个用于指向开辟的新节点 
 	p=L;
 	for(int i=1;i<n;i++)
 	{
 		p=p->next;
	 }
	 q=new LNode;
	 cout<<"请输入你要插入数据：";
	 int m;
	 cin>>m;
	 q->data=m; 
	 q->next=p->next;              //将q节点指向p的next节点
	 p->next=q;                    //将p的next指向q，实现按位插入
  }

还有部分操作较为简单不一一展示。

源码部分：

第一步一定要进行初始化哦，还有得是，源码使用的是头插法建表，如果想用尾插法建表，只需要修改main方法中的 case 2部分哦（修改方式应该一眼就会，我就不过多解释了）。

#include<iostream>
using namespace std;

typedef struct node  //typedef是函数的重命名 
{
	int data;         //存储结点，包括 data域和 next域 
	struct node *next;
}LNode ,*LinkList; 
//建立带头结点的单链表 
void InitList(LinkList &L)
{
	L=new LNode;
	L->next=NULL;
 } 
 
 //头插法建表   输入结果与输出结果相反 
void InputList_H(LinkList &L,int n)
 {
 	LNode *p;                            //用于专门开辟新的结点                     
	cout<<"请输入这"<<n<<"个数：";                           
 	for(int i=1;i<=n;i++)
 	{
 		p=new LNode;                     //申请链表LNode的空间                         
 		cin>>p->data;
 		//将新结点插入头节点后面
 		p->next = L->next;
 		L->next = p;
	 }
}


//尾插法建表  输入顺序与输出顺序一致 
void InputList_R(LinkList &L,int n)
{
	LNode *p;                         //用于专门开辟新的结点
	LNode *r;                         //用于指向表尾结点 
	r=L; 
	while(r->next!=NULL)              //先遍历链表在插入 
	{
		r=r->next;
	}
	cout<<"请输入这"<<n<<"个数：";
	for(int i=1;i<=n;i++)
	{
		p=new LNode;                  //申请链表LNode的空间
		cin>>p->data; 
		//将新结点插入表尾 
		r->next=p;
		r=p;        //将新插入的结点的指针p变为指针r，把插入的结点变为新的尾结点 
	}
	r->next=NULL;
}


//链表显示
void ShowList(LinkList &L) 
{
	LNode *p;   //用于专门开辟新的结点
	p=L->next;  //先将遍历指针指向头部，用头部往下进行遍历 
	cout<<"它的值如下："<<endl;
	while(p!=NULL)
	{
		cout<<p->data<<"\t";
		p=p->next; 
	 } 
}	

//计算表长    通过遍历的方法进行计算表的长度 
void GetLength(LinkList &L)
{
	LNode *p;   //用于专门开辟新的结点
	p=L->next;  //先将遍历指针指向头部，用头部往下进行遍历
	int i=0;      //头结点不做计算   
	while(p!=NULL)
	{
		p=p->next;
		i=i+1; 
	 } 
	 cout<<"该表长是："<<i<<endl;
 } 
 
 //在表尾进行出入 
 void InsertR(LinkList &L)
 {
 	LNode *p;                         //用于专门开辟新的结点
 	p =new LNode;                     //申请链表LNode的空间 
 	p->next=NULL;
	 cout<<"请输入插入的值：";
	 cin>>p->data;
	 LNode *r=L;                   //通过r的遍历找到表尾结点 
	 while(r->next!=NULL)
	 {
	 	r=r->next;
	  } 
	  r->next=p;
 }
 
	 //按位置进行查找
	void ShowOne(LinkList &L,int n)
	{
		LNode *p;            //用于专门开辟新的结点
		p=L->next;           //要向下进行遍历，所以该指针要先指向第一个（头结点的下一个） 
		for(int i=1;i<n;i++)
		{
			p=p->next;
		}
		cout<<"这个位置的值是："<<p->data<<endl;
	 } 
	 
 
 //按位置删除
 void DelList_W(LinkList &L,int n)
 {
 	LNode *p,*q;     //开辟两个新的指针，一个用于先遍历查找到要删除的结点， 
 	p=L;
 	for(int i=1;i<n;i++)
 	{
 		p=p->next;
	 }
	 q=p->next;                 //此时的q正指向要删除的的结点 
	 p->next=q->next;           //q指的是被删除的结点的前驱，删除q后，q后续的结点要向前 
	 delete(q);                 //删除q 
	 while(p->next!=NULL)       //将q后续的结点推向前 
	 {
	 	p=p->next;
	 }
  } 
  //安元素删除
  void DelList_Y(LinkList &L,int n)
  {
  	LNode *p,*q;
  	p=L->next;
  	while(p->data!=n)
  	{
  		p=p->next;
	  }
	   p=q->next;                 //此时的p正指向要删除的的结点 
	 q->next=p->next;           //q指的是被删除的结点的前驱，删除p后，p后续的结点要向前 
	 delete(p);                 //删除p 
	 while(q->next!=NULL)       //将p后续的结点推向前 
	 {
	 	q=q->next;
	 }
   } 
    //按位置插入 
 void DelList_I(LinkList &L,int n)
 {
 	LNode *p,*q;     //开辟两个新的指针，一个用于遍历，查一个用于指向开辟的新节点 
 	p=L;
 	for(int i=1;i<n;i++)
 	{
 		p=p->next;
	 }
	 q=new LNode;
	 cout<<"请输入你要插入数据：";
	 int m;
	 cin>>m;
	 q->data=m; 
	 q->next=p->next;
	 p->next=q; 
  } 
int main()
{
	LNode *head;
	/*LinkList head;*/                 //LinList head    等价于   LNode *head 
	int n;
	do
	{
		cout<<"\t1 初始化"<<endl;
		cout<<"\t2 输入"<<endl;
		cout<<"\t3 显示"<<endl;
		cout<<"\t4 长度"<<endl;
		cout<<"\t5 尾插入"<<endl;
		cout<<"\t6 位置查找"<<endl;
		cout<<"\t7 按位置删除"<<endl;
		cout<<"\t8 按位置插入"<<endl;
		cout<<"\t9 删除某个元素"<<endl;
		cout<<"\t0 退出操作"<<endl;
		cout<<"  选择： ";
		cin>>n;
		
		switch(n)
			{
			case 1:
				InitList(head);     //创建单链表 
			    cout<<endl;
			    break;
			case 2:
				int m;
			    cout<<"\n\t请输入数据量：";
			    cin>>m;
			    InputList_H(head,m);       //头插法 
			    //InputList_R(head,d);   //尾插法 
			    cout<<endl;
			    break;
			case 3:
				ShowList(head);  //链表的显示 
		 	    cout<<endl<<endl;
			 	break;
			case 4:
				GetLength(head);    //计算链表长度 
				break;
			case 5:
				InsertR(head);   //在表尾借进行插入 
				break;
			case 6:
				int d;
		 	    cout<<"请输入查找的位置：";
		 	    cin>>d;
		 	    ShowOne(head,d);     //位置查找 
		 	    break;
		 	case 7:
		 		int p;
		 	    cout<<"请输入删除的位置：";
		 	    cin>>p;
		 	    DelList_W(head,p);   //位置删除 
		 	    break;
		 	case 8:
		 		int q;
		 		cout<<"请输入插入的位置：";
		 		cin>>q;
		 		DelList_I(head,q);
		 		break;
		 	case 9:
		 		int a;
		 	    cout<<"请输入删除的元素：";
		 	    cin>>a;
		 	    DelList_Y(head,a);  //元素删除 
		 	    break;
		 	default:
		 		break;
			}

	}while(n!=0);
	return 0;
}

顽强的土拨鼠
关注
  • 7
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构-单链表-实验报告.rar_C++_tripk8z_单链表_单链表实验_实验报告
09-21
（1）掌握线性表的顺序存储结构； （2）验证单链表及其基本操作的实现； （3）进一步理解算法与程序的关系，能够将单链表算法转换为对应的程序。 1.2 实验要求： （1）用头插法（或尾插法）建立带头结点的单链表； ...
C++实现单链表（Single Linked List）
weixin_42133358的博客
05-14 7891
C++实现单链表（Single Linked List） 语言这个东西不用真的会忘， 我记得前前后后C++的基本语法我也看了好几遍了，一直没有动手写过什么东西，所以一遍遍的看，一遍遍的忘… … 正好最近在看数据结构，想着自己用C++来实现一下，一方面是熟悉整个逻辑过程，加深对数据结构的理解，另一方面，也熟悉一下C++。 单链表是线性表的链式存储结构，同顺序存储结构（可以理解为C++中的数组）不同的是，单链表在插入和删除一个结点时，不需要移动大量的元素，但是单链表没有数组中索引的概念，所以在查询一个元素
数据结构-单链表(c++)超全超详细
Abieai的博客
11-26 7485
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、单链表是什么？二、单链表上基本操作的实现1.定义单链表2.单链表初始化3.头插法4.尾插法5.任意位置插入6.按位取值7.按值取位8.删除结点9.打印链表10.销毁链表三、完整代码(功能过多，建议注释一部分使用)总结 前言 顺序表可以随时存取表中的任意一个元素，它的存储位置可以用一个简单直观的公式表示，但插入和删除操作需要移动大量元素。链式存储线性表时，不需要使用地址的连续存储单元，即不要求逻辑上相邻元素在物理地址上也相邻
C++——单链表的详细讲解
最新发布
imaima666的博客
05-16 973
链表是一种数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的指针。链表中的节点可以在内存中不连续地存储，通过指针来连接彼此。链表可以是单向链表，双向链表或循环链表。链表的优点是可以动态地分配内存空间，插入和删除操作效率高，但查找操作效率较低。
C++ 链表
m0_62175410的博客
07-26 3万+
C++链表笔记
C++实现单链表【每一步详细深入讲解，代码清晰、简单、易懂】
weixin_55755506的博客
12-03 4658
例如：我们需要在伪头节点（不包含数据）和含有1的节点之间插入一个节点，发现，只需要改变dummy的指针和需要插入的指针即可。通过对插入和删除的讨论，我们了解到，插入调用find函数时，并不需要操作其返回值，所以，返回值具体是该元素的节点还是其前面的节点并没有影响；，而第一个节点的前一个节点是dummy，这也是为什么我们需要dummy这个伪头节点。，因此，删除操作时我们必须得到需要删除节点的前一个节点，因此。先将要添加的元素的指针指向dummy节点的后一个节点。将要添加节点的指针指向之前的下一个节点。
单链表（C++）
weixin_63198483的博客
11-14 1169
数据结构与算法---单链表上的各项操作（C++）
C++ 数据结构与算法（四）（链表）
chenyfan_blog
02-24 6853
链表 LeetCode 代码随想录
数据结构-单链表以及对单链表进行的操作
01-08
数据结构-单链表以及对单链表进行的操作
数据结构学习笔记-单链表
02-16
在所有数据结构中，链表是一种基础且重要的类型，尤其是单链表。本学习笔记将聚焦于单链表的概念、操作以及在VS2022环境下如何实现。 单链表是一种线性数据结构，其元素（节点）不是在内存中连续存储的，而是通过...
数据结构--单链表操作--实验报告.doc
07-11
数据结构中的单链表是一种线性数据结构，由一系列节点（也称为元素或记录）...通过这个实验，学生不仅能够熟悉Visual C++的编程环境，还能深入理解单链表数据结构及其操作，为后续更复杂的数据结构和算法学习打下基础。
单链表-C++数据结构之单链表实现.zip
03-13
单链表是计算机科学中一种基础且重要的数据结构，它在C++中有着广泛的应用。在C++中实现单链表，需要理解链表的基本概念、节点结构以及相关的操作。以下是对这一主题的详细讲解： 1. **链表概念**： 链表是一种...
[Python]数据结构--链表
Festinatione facit vastum
01-11 617
[Python]数据结构–链表 ‘Festinatione facit vastum’ 链表的概念 单链表的实现 循环单链表的实现 链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另
C++ 单链表
vivian_ll的博客
10-22 1674
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)，简单来说链表并不像数组那样将数组存储在一个连续的内存地址空间里，它们可以不是连续的因为他们每个节点保存着下一个节点的引用（地址），所以较之数组来说这是一个优势。 ...
C++数据结构---单链表
weixin_45196915的博客
09-08 1228
C++数据结构—单链表 基础知识 单链表是线性表的一种，是指用链式存储结构表示线性关系，使逻辑上相邻的元素在结构上也相邻。 线性关系是指除了首元元素和尾元元素，任何结点都只有一个一个前驱和一个后继，首元没有前驱尾元没有后继。 链式存储结构不同与顺序存储结构其存储空间不是一片连续的存储单元，每个空间除了存储数据信息，还要存储数据的逻辑关系。所以用一个结点来表示，每个结点包含数据域和指针域，数据域用于存储元素本身，指针域定义了一个指针，用于指向元素的下一个结点（指向后继），从而形成链式结构。 根据链表结点所含指
C++单链表
weixin_62313265的博客
12-13 5086
链表是一种常见的数据结构。它主要是利用动态内存分配、结合结构体并配合指针来实现的，能根据需要开辟和释放内存单元。
c++链表（详解版）
热门推荐
slandarer的博客
06-13 21万+
在自学C++的时候，看到好多人都在提链表，于是就自学了一下，看了很多别人的文章，加入了一些自己的理解，做了一下总结
c++数据结构—单向链表
qq_67972375的博客
03-14 1565
由两部分组成：数据域和指针域,每个结点都有一个指针，每个节点指针的指向都是指向自身结点的下一个结点，最后一个结点的head指向为NULL,对单链表的操作只能从一端开始，如果需要查找链表中的某一个结点，则需要从头开始进行遍历。
C++ 万字长文，链表详解
jinjiayang的博客
12-02 4803
C++链表详解（包括迭代器，链式存储等诸多干货）
数据结构单链表c++
08-24
单链表是一种常见的数据结构，用于存储一系列的节点连接起来的数据。 在C语言中，我们可以使用结构体来定义一个节点，包含一个数据域和一个指向下一个节点的指针域。代码如下： ```c struct Node { int data; struct Node* next; }; ``` 然后，我们可以定义一个指向链表头部的指针，表示整个链表的起始位置。初始化链表时，这个指针可以指向NULL。 ```c struct Node* head = NULL; ``` 接下来，我们可以实现一些基本的操作，例如插入节点、删除节点、遍历链表等。 插入节点的过程包括创建一个新节点，并将其插入到链表中适当的位置。 ```c void insertNode(int value) { struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); newNode->data = value; newNode->next = NULL; if (head == NULL) { head = newNode; } else { struct Node* curr = head; while (curr->next != NULL) { curr = curr->next; } curr->next = newNode; } } ``` 删除节点的过程需要找到目标节点，并调整前后节点的指针。 ```c void deleteNode(int value) { if (head == NULL) { return; } if (head->data == value) { struct Node* temp = head; head = head->next; free(temp); return; } struct Node* prev = head; struct Node* curr = head->next; while (curr != NULL && curr->data != value) { prev = curr; curr = curr->next; } if (curr != NULL) { prev->next = curr->next; free(curr); } } ``` 遍历链表的过程是从头节点开始，依次打印每个节点的数据。 ```c void printList() { struct Node* curr = head; while (curr != NULL) { printf("%d ", curr->data); curr = curr->next; } printf("\n"); } ``` 这是一个简单的单链表的实现示例，你可以根据需要进一步扩展和优化。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值